Spring总结 一

编程语言 2018-07-20 01:28:56 阅读次数: 0

Spring 总结1

  1. Spring入门
    1. Spring介绍

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益

简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

    1. ☆使用Spring好处
  2. 方便解耦，简化开发
    1. Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
  3. AOP编程的支持
    1. Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
  4. 声明式事务的支持
    1. 只需要通过配置就可以完成对事务的管理，而无需手动编程
  5. 方便程序的测试
    1. Spring对Junit4支持，可以通过注解方便的测试Spring程序
  6. 方便集成各种优秀框架
    1. Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
  7. 降低JavaEE API的使用难度
    1. Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

 

    1. ★Spring体系结构

Spring 框架是一个分层架构,,它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming)、Instrumentation和测试部分,如下图所示：

 

 

  1. Spring 快速入门
    1. 编写流程
  1. 下载Spring最新开发包
  2. 复制Spring开发 jar包到工程
  3. 编写Spring核心配置文件
  4. 在程序中读取Spring配置文件，通过Spring框架获得Bean，完成相应操作

 

    1. HelloWorld 实现
      1. 下载jar

核心包：

spring-framework-3.2.2.RELEASE-dist.zip

包结构：org.springframework

第三方依赖包：

spring-framework-3.0.2.RELEASE-dependencies.zip

包结构：com.springsource

 

★Spring核心开发包

  1. spring-core-3.2.2.RELEASE.jar
    1. 包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心。
  2. spring-beans-3.2.2.RELEASE.jar
    1. 所有应用都要用到的，它包含访问配置文件、创建和管理bean
    2. 以及进行Inversion of Control(IoC) / Dependency Injection(DI)操作相关的所有类
  3. spring-context-3.2.2.RELEASE.jar
    1. Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持,
    2. 如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各种视图层框架的封装等。
  4. spring-expression-3.2.2.RELEASE.jar
    1. Spring表达式语言
  5. com.springsource.org.apache.commons.logging-1.1.1.jar
    1. 第三方的主要用于处理日志

 

      1. 编写业务类

package cn.itcast.a.hello;

 

public class HelloService {

   

    private String info;                //普通字段

    public void setInfo(String info){   //为字段提供setter方法

       this.info = info;

    }

   

    public void sayInfo(){

       System.out.println("你好," + info);

    }

 

}

 

 

      1. 传统方式创建实例

package cn.itcast.a.hello;

 

public class TestHello {

   

    public static void main(String[] args) {

       //传统自己创建new

       HelloService service = new HelloService();

    }

}

 

 

      1. Spring IoC控制反转创建实例

编写配置文件( Spring 容器)

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                      http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloService" class="cn.itcast.a.hello.HelloService">

    </bean>

</beans>

 

 

从spring容器获得对象实例

package cn.itcast.a.hello;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestHello {

    public static void main(String[] args) {

       //使用spring 控制反转，交予spring创建对象

       ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("cn/itcast/a/hello/beans.xml");

       HelloService servcie =

(HelloService) applicationContext.getBean("helloService");

    }

}

 

 

IoC解释

IoC Inverse of Control 反转控制的概念，就是将原本在程序中手动创建HelloService对象的控制权，交由Spring框架管理，简单说，就是创建HelloService对象控制权被反转到了Spring框架

 

 

      1. 传统方式设置内容

package cn.itcast.a.hello;

public class TestHello {

  

   public static void main(String[] args) {

      //传统自己创建new

      HelloService service = new HelloService();

      service.setInfo("lt");          //手动设置内容

      service.sayInfo();

   }

}

 

 

      1. Spring DI 设置字段内容

编写配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                      http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloService" class="cn.itcast.a.hello.HelloService">

       <!—通过spring容器，给HelloService类的info属性注入“传智播客”-->

       <property name="info" value="传智播客"></property>

    </bean>

</beans>

 

 

从spring直接获得注入的内容

package cn.itcast.a.hello;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestHello {

   

    public static void main(String[] args) {

       //使用spring 控制反转，交予spring创建对象

       ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("cn/itcast/a/hello/beans.xml");

       HelloService servcie =

(HelloService) applicationContext.getBean("helloService");

      

       //servcie.setInfo("传智播客");

       servcie.sayInfo();

    }

 

}

 

 

DI解释

    DI：Dependency Injection 依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件。

    getBean("helloService")从spring容器中获得指定名称对象的实例时，通过此设置<property name="info" value="传智播客"></property> 相当于执行 servcie.setInfo("传智播客");

 

 

    1. 加载spring 容器的三种方式
      1. ★类路径获得配置文件

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("cn/itcast/a/hello/beans.xml");

  1. ClassPathXmlApplicationContext(String)加载一个spring容器
  2. ClassPathXmlApplicationContext(String[])加载多个spring容器
      1. 文件系统路径获得配置文件

ApplicationContext applicationContext =

new FileSystemXmlApplicationContext("F:\\workspaces\\spring\\day01\\src\\cn\\itcast\\a\\hello\\beans.xml");

      1. 使用BeanFactory(了解)

BeanFactory beanFactory =

new XmlBeanFactory(new FileSystemResource("F:\\workspaces\\spring\\day01\\src\\cn\\itcast\\a\\hello\\beans.xml"));

 

      1. BeanFactory和ApplicationContext对比

BeanFactory 采取延迟加载，第一次getBean时才会初始化Bean

ApplicationContext是对BeanFactory扩展，提供了更多功能

国际化处理

事件传递

Bean自动装配

各种不同应用层的Context实现

 

 

  1. 装配Bean(xml)
    1. 实例化Bean的三种方式
      1. 使用构造方法实例化
  1. 在spring容器中配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

   <!--2  第一种方式 默认构造 -->

   <bean id="demo1User" class="cn.itcast.b_xmlbean.demo1.User"></bean>

  

</beans>

 

  1. 测试

public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

      User user = (User)applicationContext.getBean("demo1User");

     

      System.out.println(user);

     

     

}

 

  1. 对比

相当于：User user = new User();               //直接创建实例

      1. 使用静态工程方法实例化
  2. 在spring容器中配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

   <!-- 第二种方式 静态工厂方法 ， 没有工厂的实例对象-->

   <bean id="demo2User" class="cn.itcast.b_xmlbean.demo2.Demo2BeanFactory" factory-method="getDemo2Bean"></bean>

  

</beans>

 

  1. 提供工厂类

package cn.itcast.b_xmlbean.demo2;

public class Demo2BeanFactory {

  

   public Demo2BeanFactory(){

      System.out.println("demo2 不执行");

   }

  

   /**

    * 必须提供 static方法

    * @return

    */

   public static User getDemo2Bean(){

      return new User();

   }

 

}

 

 

  1. 测试

public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

      User user = (User)applicationContext.getBean("demo2User");

     

      System.out.println(user);

     

     

   }

 

 

  1. 对比

相当于： User user = BeanFatory.getUserBean();     //通过工厂的静态方法获得需要的内容

      1. 使用实例工程方法
  2. 在Spring容器的配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

  

   <!-- 第三种方式 实例工厂方法

      * 先实例工厂

      * 通过实例工厂执行具体的方法

    -->

   <bean id="demo3BeanFactory" class="cn.itcast.b_xmlbean.demo3.Demo3BeanFactory"></bean>

   <bean id="demo3User" factory-bean="demo3BeanFactory" factory-method="getDemo2Bean"></bean>

  

  

</beans>

 

  1. 提供工厂类

package cn.itcast.b_xmlbean.demo3;

public class Demo3BeanFactory {

  

   public Demo3BeanFactory(){

      //System.out.println("demo3 执行");

   }

  

   /**

    * 非静态方法

    * @return

    */

   public User getDemo2Bean(){

      return new User();

   }

 

}

 

  1. 测试

   public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

      User user = (User)applicationContext.getBean("demo3User");

     

      System.out.println(user);

     

     

   }

 

  1. 对比

相当于：

BeanFactory factory = new BeanFactory();         //先创建工厂

User user = factory.getUserBean();                     //在通过工厂的实例对象，执行非静态方法获得具体内容

 

 

    1. spring容器中bean元素id和name属性的区别

在spring容器中添加以下配置：

<bean id="helloService" class="cn.itcast.a.hello.HelloService">

bean节点中Id和name的区别：

  1. 区别一：
    1. id:指定唯一实例引用
    2. name:可以指定多个实例引用，例如name=“名称1,名称2”
  2. 区别二：
    1. id ：id的命名要满足XML对ID属性命名规范
      1. 例如：必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号
    2. name:如果Bean的名称中含有特殊字符，就需要使用name属性
      1. 例如：<bean name="# boy " class="cn.itcast.ioc.Boy"/>
      2. 因为name属性可以相同，所以后出现Bean会覆盖之前出现的同名的Bean

总结：项目开发的时候，强烈要求用id，因为id可以表示惟一引用。

 

    1. Bean的作用域

类别

说明

singleton

在Spring IoC容器中仅存在一个Bean实例，Bean以单例方式存在，默认值

prototype

每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()

request

每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境

session

同一个HTTP Session 共享一个Bean，不同Session使用不同Bean，仅适用于WebApplicationContext 环境

globalSession

一般用于Portlet应用环境，该作用域仅适用于WebApplicationContext 环境

 

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

   <!-- 4 bean 作用域

      * singleton 单例，只创建一个实例。默认值

      * prototype 多例，每一次都创建实例

      * request，request范围，request.setAttribute

      * session，session范围，session.setAttribute

      * globalSession ， prolet 分布式门户，sso(单点登录)将不同的应用的数据保存到globalSession中，达到数据共享

    -->

    <bean id="person" class="cn.itcast.c_beanscope.Person" scope="prototype"></bean>

  

</beans>

 

public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

     

      Person p1 = (Person) applicationContext.getBean("person");

      System.out.println(p1);

     

      Person p2 = (Person) applicationContext.getBean("person");

      System.out.println(p2);

     

     

      //WebApplicationContextUtils.getRequiredWebApplicationContext(null);

     

      WebApplicationContext applicationContext2 = null;

     

   }

 

    1. Bean的生命周期
      1. 生命周期详情
  2. instantiate bean对象实例化
  3. populate properties 封装属性
  4. 如果Bean实现BeanNameAware 执行 setBeanName
  5. 如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext
  6. 如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessBeforeInitialization
  7. 如果Bean实现InitializingBean 执行 afterPropertiesSet
  8. 调用<bean init-method="init"> 指定初始化方法 init
  9. 如果存在类实现 BeanPostProcessor（处理Bean） ，执行postProcessAfterInitialization
  10. 执行业务处理
  11. 如果Bean实现 DisposableBean 执行 destroy
  12. 调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy

 

      1. 实现

测试代码，实现类：

package cn.itcast.d_lifecycle;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.BeanNameAware;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

 

public class User implements BeanNameAware ,ApplicationContextAware,InitializingBean ,DisposableBean {

  

   public User() {

      System.out.println("1.构造方法执行");

   }

  

   private String username;

   private String password;

   public String getUsername() {

      return username;

   }

   public void setUsername(String username) {

      System.out.println("2 装载属性，调用setter方法");

      this.username = username;

   }

   public String getPassword() {

      return password;

   }

   public void setPassword(String password) {

      this.password = password;

   }

   @Override

   public void setBeanName(String name) {

      System.out.println("3.通过BeanNameAware接口，获得配置文件id属性的内容：" + name);

   }

   @Override

   public void setApplicationContext(ApplicationContext applicationContext)

          throws BeansException {

      System.out.println("4.通过ApplicationContextAware接口，获得Spring容器，" + applicationContext);

   }

   /** 5 在后处理bean MyBeanPostProcessor.java 处 */

   @Override

   public void afterPropertiesSet() throws Exception {

      System.out.println("6.通过InitializingBean，确定属性设置完成之后执行");

   }

  

   public void userInit(){

      System.out.println("7.配置init-method执行自定义初始化方法");

   }

   /** 8  在后处理bean MyBeanPostProcessor.java 处 */

   @Override

   public void destroy() throws Exception {

      System.out.println("9.通过DisposableBean接口，不需要配置的销毁方法");

   }

  

   public void userDestroy(){

      System.out.println("10.配置destroy-method执行自定义销毁方法");

   }

 

}

 

 

Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

    <!-- 5 lifecycle 生命周期

      1.构造方法执行

      2 装载属性，调用setter方法

      3.通过BeanNameAware接口，获得配置文件id属性的内容：lifeUser

      4.通过ApplicationContextAware接口，获得Spring容器

      5. 实现BeanPostProcessor后处理，初始化前，执行postProcessBeforeInitialization方法

      6.通过InitializingBean，确定属性设置完成之后执行

      7.配置init-method执行自定义初始化方法

      8. 实现BeanPostProcessor后处理，在自定义初始化之后，执行postProcessAfterInitialization方法

      // 执行操作

      9.通过DisposableBean接口，不需要配置的销毁方法

      10.配置destroy-method执行自定义销毁方法

 

   -->

    <bean id="lifeUser" class="cn.itcast.d_lifecycle.User" init-method="userInit" destroy-method="userDestroy">

      <property name="username" value="jack"></property>

      <property name="password" value="1234"></property>

    </bean>

    <!-- 5.1配置 后处理bean -->

    <bean class="cn.itcast.d_lifecycle.MyBeanPostProcessor"></bean>

    

    

</beans>

 

 

测试类

public static void main(String[] args) {

     

      ClassPathXmlApplicationContext applicationContext =

 new ClassPathXmlApplicationContext("applicationContext.xml");

      System.out.println("---->" + applicationContext);

     

      User user = (User) applicationContext.getBean("lifeUser");

      System.out.println(user); //业务执行

     

     

      //必须手动执行关闭，才可以进行之后销毁的操作

      applicationContext.close();

     

   }

 

后处理bean

package cn.itcast.d_lifecycle;

 

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.BeanPostProcessor;

 

/**

 * 后处理bean处理程序

 * 需要注册给Spring容器，统一处理所有的bean，只需要注册

 * @author lt

 *

 */

public class MyBeanPostProcessor implements BeanPostProcessor {

 

   @Override

   public Object postProcessBeforeInitialization(Object bean, String beanName)

          throws BeansException {

      if("lifeUser".equals(beanName)){

          System.out.println("5. 实现BeanPostProcessor后处理Bean，初始化前 : " + beanName + "，bean实例：  " + bean);

      }

      return bean; //返回当前bean，不做任何处理，可以生产代理类

   }

 

   @Override

   public Object postProcessAfterInitialization(Object bean, String beanName)

          throws BeansException {

      if("lifeUser".equals(beanName)){

          System.out.println("8. 实现BeanPostProcessor后处理Bean，在自定义初始化之后 : " + beanName);

      }

      return bean;

   }

}

 

 

运行结果

1.构造方法执行

2 装载属性，调用setter方法

3.通过BeanNameAware接口，获得配置文件id属性的内容：lifeUser

4.通过ApplicationContextAware接口，获得Spring容器，

org.springframework.context.support.ClassPathXmlApplicationContext@169d75d:

startup date [Sun Jun 29 23:39:07 CST 2014]; root of context hierarchy

5. 实现BeanPostProcessor后处理，初始化前 : lifeUser，bean实例：  cn.itcast.d_lifecycle.User@1c9f789

6.通过InitializingBean，确定属性设置完成之后执行

7.配置init-method执行自定义初始化方法

8. 实现BeanPostProcessor后处理，在自定义初始化之后 : lifeUser

---->org.springframework.context.support.ClassPathXmlApplicationContext@169d75d:

startup date [Sun Jun 29 23:39:07 CST 2014]; root of context hierarchy

cn.itcast.d_lifecycle.User@1c9f789

9.通过DisposableBean接口，不需要配置的销毁方法

10.配置destroy-method执行自定义销毁方法

 

    1. 依赖注入Bean属性(xml)
      1. 注入方式
  2. 手动装配，使用xml配置
    1. 构造方法注入
    2. 属性setter方法注入
    3. 接口注入 – spring不支持
  3. 自动装配

 

 

      1. 手动装配—构造方法
  2. Bean对象

package cn.itcast.e_propinject.constructor;

 

public class User {

  

   private String username;

   private int age;

   private String password;

   private int money;

  

   public User(int money,String password) {    //构造1

      this.password = password;

      this.money = money;

   }

 

   public User(String username, int age) {     //构造2

      this.username = username;

      this.age = age;

   }

  

   @Override

   public String toString() {

      return "User [username=" + username + ", age=" + age + ", password="

             + password + ", money=" + money + "]";

   }

}

 

 

  1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 6.1构造方法注入 -->

    <bean id="injectConstructorUser" class="cn.itcast.e_propinject.constructor.User">

      <constructor-arg index="0"  value="1111"></constructor-arg>

      <constructor-arg index="1"  value="123456"></constructor-arg>

    </bean>

    

</beans>

 

 

  1. 测试类

public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

     

      User user = (User) applicationContext.getBean("injectConstructorUser");

      System.out.println(user); //业务执行

     

     

   }

 

  1. 运行结果

User [username=null, age=0, password=123456, money=1111]

 

  1. 对比

如果“构造1”和“构造2”互换位置，运行结果是

public User(String username, int age) {      //构造2

      this.username = username;

      this.age = age;

   }

  

   public User(int money,String password) { //构造1

      this.password = password;

      this.money = money;

   }

 

User [username=1111, age=123456, password=null, money=0]

 

  1. 注意：

 

在开发中为了指定执行的是那个构造方法，一般代用index属性和type属性结合的方式

 

<bean[lt1]  id="injectConstructorUser" class="cn.itcast.e_propinject.constructor.User">

      <constructor-arg index="0"  value="1111" type="int"></constructor-arg>

      <constructor-arg index="1"  value="123456" type="java.lang.String"></constructor-arg>

    </bean>

 

 

      1. 手动装配—setter方法
  2. Bean对象

package cn.itcast.e_propinject.property;

 

public class User {

  

   private String userName;

   private String password;

   public String getUserName() {

      return userName;

   }

   public void setUserName(String userName) {

      this.userName = userName;

   }

   public String getPassword() {

      return password;

   }

   public void setPassword(String password) {

      this.password = password;

   }

   @Override

   public String toString() {

      return "User [userName=" + userName + ", password=" + password + "]";

   }

}

 

 

 

  1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

    <!-- 6.2.1 setter方法  普通字段-->

     <bean id="propertyInjectUser" class="cn.itcast.e_propinject.property.User">

     <property name="userName" value="rose"></property>

     <property name="password" value="5555"></property>

     </bean>

    

</beans>

 

  1. 测试类

public static void main(String[] args) {

     

      ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

     

      User user = (User) applicationContext.getBean("propertyInjectUser");

      System.out.println(user); //业务执行

     

     

   }

 

      1. 手动装配—方法注入

将已有的方法增强

如何将一个prototype(多例) bean注入给singleton(单例) Bean

 

  1. Bean对象

Service

 

package cn.itcast.e_propinject.method;

 

public class UserService {

  

   private Dao dao = new UserMySqlDao();

  

   public Dao getDao() {

      return dao;

   }

  

   public void find(){

      getDao().find();

   }

 

}

 

 

Dao接口

package cn.itcast.e_propinject.method;

 

public interface Dao {

  

   public void find();

 

}

 

 

Mysql实现

 

package cn.itcast.e_propinject.method;

 

public class UserMySqlDao implements Dao {

  

   public void find(){

      System.out.println("mysql 查询");

   }

 

}

 

 

 

Oracle实现

 

package cn.itcast.e_propinject.method;

 

public class UserOracleDao implements Dao{

   public void find(){

      System.out.println("oracle 查询");

   }

}

 

 

 

  1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

   <!-- 不修改UserService原有代码的前提下，扩展service -->

   <bean id="methodUserService" class="cn.itcast.e_propinject.method.UserService">

      <lookup-method name="getDao" bean="methodOracleDao"/>

   </bean>

   <bean id="methodOracleDao" class="cn.itcast.e_propinject.method.UserOracleDao"></bean>

     

</beans>

 

 

  1. 测试

package cn.itcast.e_propinject.method;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class TestService {

  

   public static void main(String[] args) {

     

      ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

     

      UserService userService = (UserService) applicationContext.getBean("methodUserService");

      userService.find();

   }

 

}

 

 

 

      1. 手动装配—p命名空间
  2. Bean对象

package cn.itcast.e_propinject.p;

 

public class User {

  

   private String userName;

   private String password;

   public String getUserName() {

      return userName;

   }

   public void setUserName(String userName) {

      this.userName = userName;

   }

   public String getPassword() {

      return password;

   }

   public void setPassword(String password) {

      this.password = password;

   }

   @Override

   public String toString() {

      return "User [userName=" + userName + ", password=" + password + "]";

   }

 

  

  

}

 

 

  1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

      xmlns:p[lt2] ="http://www.springframework.org/schema/p"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

     <!--  6.2.3 p命名空间  -->

     <bean id="pInjectUser" class="cn.itcast.e_propinject.p.User" p:userName[lt3] ="tom" p:password="9999"></bean>

</beans>

 

 

 

      1. 手动装配—集合属性

 

List/Array集合

Bean对象

 

package cn.itcast.f_collection.a_list;

 

import java.util.List;

 

public class User {

  

   private List<String> loves;

   private String[] interest;

 

   public List<String> getLoves() {

      return loves;

   }

 

   public void setLoves(List<String> loves) {

      this.loves = loves;

   }

 

   @Override

   public String toString() {

      return "User [loves=" + loves + "]";

   }

 

   public String[] getInterest() {

      return interest;

   }

 

   public void setInterest(String[] interest) {

      this.interest = interest;

   }

  

  

 

}

 

 

Spring 容器

位置：/src/cn/itcast/f_collection/a_list/beans.xml

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

      

    <bean id="user" class="cn.itcast.f_collection.a_list.User">

       <property name="loves">

          <list>

             <value>小龙女</value>

             <value>凤儿</value>

          </list>

       </property>

      

       <property name="interest">

          <array>

             <value>葵花</value>

             <value>菊花</value>

          </array>

       </property>

    </bean> 

</beans>

 

 

测试

 

package cn.itcast.f_collection.a_list;

 

import java.util.Arrays;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/f_collection/a_list/beans.xml");

     

      User user = (User) context.getBean("user");

     

      System.out.println(user.getLoves());

      System.out.println(Arrays.toString(user.getInterest()));

   }

 

}

 

 

 

结果：

[小龙女, 凤儿]

[葵花, 菊花]

 

 

 

Set集合

Bean对象

 

package cn.itcast.f_collection.b_set;

 

import java.util.Set;

 

public class User {

  

   private Set<String> loves;

 

   public Set<String> getLoves() {

      return loves;

   }

 

   public void setLoves(Set<String> loves) {

      this.loves = loves;

   }

  

 

}

 

 

Spring容器

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

      

    <bean id="user" class="cn.itcast.f_collection.b_set.User">

       <property name="loves">

          <set>

             <value>小龙女</value>

             <value>凤儿</value>

          </set>

       </property>

      

    </bean> 

</beans>

 

 

测试

 

package cn.itcast.f_collection.b_set;

 

import java.util.Arrays;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/f_collection/b_set/beans.xml");

     

      User user = (User) context.getBean("user");

     

      System.out.println(user.getLoves());

   }

 

}

 

 

运行结果

[小龙女, 凤儿]

 

 

 

Map集合

Bean对象：Book对象

package cn.itcast.f_collection.c_map;

 

public class Book {

 

}

 

Bean对象：User对象

 

package cn.itcast.f_collection.c_map;

 

import java.util.Map;

 

public class User {

  

   private Map<String,Book> data;

 

   public Map<String, Book> getData() {

      return data;

   }

 

   public void setData(Map<String, Book> data) {

      this.data = data;

   }

  

  

  

}

 

 

 

Spring 容器

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

   

    <bean id="bookId" class="cn.itcast.f_collection.c_map.Book"></bean>

       

    <bean id="user" class="cn.itcast.f_collection.c_map.User">

       <property name="data">

          <map>

             <!-- 第一种写法 -->

             <entry key="b001" value-ref="bookId">

             </entry>

            

             <!-- 第二种写法 -->

             <entry>

                <key >

                   <value>b002</value>

                </key>

                <ref bean="bookId"/>

             </entry>

          </map>

       </property>

      

    </bean> 

</beans>

 

 

 

测试

package cn.itcast.f_collection.c_map;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/f_collection/c_map/beans.xml");

     

      User user = (User) context.getBean("user");

     

      System.out.println(user.getData());

   }

 

}

 

 

结果：

{b001=cn.itcast.f_collection.c_map.Book@15e7bc4, b002=cn.itcast.f_collection.c_map.Book@15e7bc4}

 

 

Properties对象

Bean对象

 

package cn.itcast.f_collection.d_prop;

 

import java.util.Properties;

 

public class User {

  

   private Properties properties;

 

   public Properties getProperties() {

      return properties;

   }

 

   public void setProperties(Properties properties) {

      this.properties = properties;

   }

  

}

 

 

Spring容器

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

   

    <bean id="user" class="cn.itcast.f_collection.d_prop.User">

       <property name="properties">

          <props>

             <prop key="1">男</prop>

             <prop key="2">女</prop>

          </props>

       </property>

      

    </bean> 

</beans>

 

 

测试

package cn.itcast.f_collection.d_prop;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/f_collection/d_prop/beans.xml");

     

      User user = (User) context.getBean("user");

     

      System.out.println(user.getProperties());

   }

 

}

 

 

结果：

{2=女, 1=男}

 

 

    1. Bean关系
      1. 继承
  2. 如果多个Bean具有相同的方法和属性，则可以引入父类Bean，配置父子bean关系

Bean对象

 

package cn.itcast.g_relation.a_extends;

 

public class User {

  

   private String username;

   private int age;

 

   public String getUsername() {

      return username;

   }

 

   public void setUsername(String username) {

      this.username = username;

   }

 

   public int getAge() {

      return age;

   }

 

   public void setAge(int age) {

      this.age = age;

   }

 

   @Override

   public String toString() {

      return "User [username=" + username + ", age=" + age + "]";

   }

}

 

 

Spring容器：

位置：cn/itcast/g_relation/a_extends/beans.xml

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

   

    <!-- 第一种方法：创建两个Bean -->

    <bean id="user1" class="cn.itcast.g_relation.a_extends.User">

       <property name="username" value="jack"></property>

       <property name="age" value="18"></property>

    </bean>

    <bean id="user2" class="cn.itcast.g_relation.a_extends.User">

       <property name="username" value="rose"></property>

       <property name="age" value="18"></property>

    </bean> 

   

    <!-- 第二种方法：继承，将公共部分提取 -->

    <bean id="baseUser" class="cn.itcast.g_relation.a_extends.User" abstract="true">

       <property name="age" value="20"></property>

    </bean>

    <bean id="user3" parent="baseUser">

       <property name="username" value="jack2"></property>

    </bean>

    <bean id="user4" parent="baseUser">

       <property name="username" value="rose2"></property>

    </bean>

</beans>

 

 

测试

package cn.itcast.g_relation.a_extends;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/g_relation/a_extends/beans.xml");

     

      User user1 = (User) context.getBean("user1");

      System.out.println(user1);

     

      User user2 = (User) context.getBean("user2");

      System.out.println(user2);

     

      User user3 = (User) context.getBean("user3");

      System.out.println(user3);

     

      User user4 = (User) context.getBean("user4");

      System.out.println(user4);

     

   }

 

}

 

 

结果

 

User [username=jack, age=18]

User [username=rose, age=18]

User [username=jack2, age=20]

User [username=rose2, age=20]

 

 

      1. 依赖
  2. 一个类内部运行依赖另一个Bean初始化一些数据

 

Bean对象：Dao

 

package cn.itcast.g_relation.b_dependent;

 

public class Dao {

  

   public Dao() {

      System.out.println("2 操作数据进行中");

   }

 

}

 

 

Bean对象：DataBase

 

package cn.itcast.g_relation.b_dependent;

 

public class DataBase {

   public DataBase() {

      System.out.println("1 数据库已经连接");

   }

}

 

 

Spring容器

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

   

    <!-- dao bean和 db bean 没有任何关系

       spring 实例化bean的顺序为<bean>配置的顺序，默认先初始化dao，再初始化db

       depends-on 用于修改初始化顺序

    -->

    <bean id="dao" class="cn.itcast.g_relation.b_dependent.Dao" depends-on="db">

    </bean>

    <bean id="db" class="cn.itcast.g_relation.b_dependent.DataBase">

    </bean> 

   

</beans>

 

 

测试

package cn.itcast.g_relation.b_dependent;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/g_relation/b_dependent/beans.xml");

     

      Dao dao = (Dao) context.getBean("dao");

      System.out.println(dao);

     

     

   }

 

}

 

 

 

结果

 

没有配置：depends-on="db"

2 操作数据进行中

1 数据库已经连接

cn.itcast.g_relation.b_dependent.Dao@8f5352

 

配置：depends-on="db"

1 数据库已经连接

2 操作数据进行中

cn.itcast.g_relation.b_dependent.Dao@8f5352

 

 

 

 

      1. 引用
  2. 一个Bean可以将另一个Bean的id注入到程序中，在运行期获得其实例

 

Bean对象：Dao

package cn.itcast.g_relation.c_ref;

 

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

 

public class Dao implements ApplicationContextAware{

  

   private String beanId;

   private ApplicationContext applicationContext;

  

   public DataBase getDB(){

      return (DataBase) applicationContext.getBean(beanId);

   }

 

   public String getBeanId() {

      return beanId;

   }

 

   public void setBeanId(String beanId) {

      this.beanId = beanId;

   }

 

   @Override

   public void setApplicationContext(ApplicationContext applicationContext)

          throws BeansException {

      this.applicationContext = applicationContext;

   }

  

 

}

 

 

Bean对象：DataBase

 

package cn.itcast.g_relation.c_ref;

 

public class DataBase {

  

}

 

 

Spring 容器

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                 http://www.springframework.org/schema/beans/spring-beans.xsd">

   

    <bean id="dao" class="cn.itcast.g_relation.c_ref.Dao">

       <property name="beanId">

          <idref bean="db"/>

       </property>

    </bean>

   

    <bean id="db" class="cn.itcast.g_relation.c_ref.DataBase">

    </bean> 

</beans>

 

 

 

测试：

package cn.itcast.g_relation.c_ref;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/g_relation/c_ref/beans.xml");

     

      Dao dao = (Dao) context.getBean("dao");

      System.out.println(dao.getBeanId());

      System.out.println(dao.getDB());

     

     

   }

 

}

 

 

结果：

db

cn.itcast.g_relation.c_ref.DataBase@2e06bd

 

 

 

 

 

 

 

 

 

 

  1. 装配Bean(注解)
    1. Spring2.5

测试类：

public class App {

  

   public static void main(String[] args) {

     

      /*

       * @Component 在spring2.5配置所有的内容

       * @Autowired 默认按照类型进行注入。如果有多个相同的类型，则按照名称进行注入

       */

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/h_annotation/a_2_5/beans.xml");

     

      Web web = (Web)context.getBean("myweb");

     

      web.save();

   }

 

}

Web层

package cn.itcast.h_annotation.a_2_5;

 

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

 

@Component("myweb")

public class Web {

  

   @Autowired

   private Service service;

  

   public void save(){

      service.save();

      System.out.println("web save");

   }

 

}

 

 

 

Service层

 

package cn.itcast.h_annotation.a_2_5;

 

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Component;

 

@Component

public class Service {

  

   @Autowired

   @Qualifier("myDao")

   private Dao dao;

  

   public void save(){

      dao.save();

      System.out.println("service save");

   }

 

}

 

 

Dao层

package cn.itcast.h_annotation.a_2_5;

 

import org.springframework.stereotype.Component;

 

@Component("myDao")

public class Dao {

 

   public void save(){

      System.out.println("dao save");

   }

}

 

Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                          http://www.springframework.org/schema/beans/spring-beans.xsd

                          http://www.springframework.org/schema/context

                          http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 确定使用注解  -->

    <context:annotation-config></context:annotation-config>

    <!-- 自动扫描指定的包 -->

    <context:component-scan base-package="cn.itcast.h_annotation.a_2_5"></context:component-scan>

</beans>

 

结果：

dao save

service save

web save

 

 

 

    1. Spring 3.0

测试类

 

package cn.itcast.h_annotation.b_3_0;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      /* @Component 衍生了以下三个注解，用于标识不同的层次

       * @Controller 用于配置表示层web

       * @Service 用于配置业务逻辑层service

       * @Repository 用于配置数据访问层dao

       */

      ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/h_annotation/b_3_0/beans.xml");

     

      Web web = (Web)context.getBean("myweb");

     

      web.save();

   }

 

}

 

Web层

 

package cn.itcast.h_annotation.b_3_0;

 

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

 

@Controller("myweb")

public class Web {

  

   @Autowired

   private Service service;

  

   public void save(){

      service.save();

      System.out.println("web save");

   }

 

}

 

 

Service层

 

package cn.itcast.h_annotation.b_3_0;

 

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

 

@org.springframework.stereotype.Service

public class Service {

  

   @Autowired

   @Qualifier("myDao")

   private Dao dao;

  

   public void save(){

      dao.save();

      System.out.println("service save");

   }

 

}

 

 

Dao层

package cn.itcast.h_annotation.b_3_0;

 

import org.springframework.stereotype.Repository;

 

@Repository("myDao")

public class Dao {

 

   public void save(){

      System.out.println("dao save");

   }

}

 

 

Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                          http://www.springframework.org/schema/beans/spring-beans.xsd

                          http://www.springframework.org/schema/context

                          http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 确定使用注解  -->

    <context:annotation-config></context:annotation-config>

    <!-- 自动扫描指定的包 -->

    <context:component-scan base-package="cn.itcast.h_annotation.b_3_0"></context:component-scan>

</beans>

 

 

结果：

dao save

service save

web save

 

    1. Bean初始化和销毁

测试类

package cn.itcast.h_annotation.c_lifecycle;

 

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      /*

       * @PostConstruct

       * public void init(){  等价于  init-method="init"

       *

       * @PreDestroy

       * public void destory(){ 等价于 destroy-method="destory"

       */

      ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/h_annotation/c_lifecycle/beans.xml");

     

      Book book = (Book)context.getBean("book");

     

      context.close();

   }

 

}

 

 

Bean对象

 

package cn.itcast.h_annotation.c_lifecycle;

 

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

 

import org.springframework.stereotype.Component;

 

@Component("book")

public class Book {

  

   @PostConstruct

   public void init(){

      System.out.println("初始化");

   }

  

   @PreDestroy

   public void destory(){

      System.out.println("销毁");

   }

 

}

 

 

Spring 容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                          http://www.springframework.org/schema/beans/spring-beans.xsd

                          http://www.springframework.org/schema/context

                          http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 确定使用注解  -->

    <context:annotation-config></context:annotation-config>

    <!-- 自动扫描指定的包 -->

    <context:component-scan base-package="cn.itcast.h_annotation.c_lifecycle"></context:component-scan>

   

    <!-- xml配置

    <bean id="book" class="cn.itcast.h_annotation.c_lifecycle.Book"

       init-method="init" destroy-method="destory">

    </bean>

    -->

</beans>

 

 

 

 

    1. Bean作用范围

测试

package cn.itcast.h_annotation.d_scope;

 

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

public class App {

  

   public static void main(String[] args) {

     

      /*

       * @Scope("singleton") 给当前bean配置范围，取值：singleton、prototype等

       */

      ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/h_annotation/d_scope/beans.xml");

     

      Book book = (Book)context.getBean("book");

      System.out.println(book);

     

      Book book2 = (Book)context.getBean("book");

      System.out.println(book2);

      context.close();

   }

 

}

 

Bean对象

 

package cn.itcast.h_annotation.d_scope;

 

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Component;

 

@Component("book")

@Scope("singleton")

//@Scope("prototype")

public class Book {

  

 

}

 

 

Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                          http://www.springframework.org/schema/beans/spring-beans.xsd

                          http://www.springframework.org/schema/context

                          http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 确定使用注解  -->

    <context:annotation-config></context:annotation-config>

    <!-- 自动扫描指定的包 -->

    <context:component-scan base-package="cn.itcast.h_annotation.d_scope"></context:component-scan>

   

</beans>

 

结果：

 

@Scope("singleton")

cn.itcast.h_annotation.d_scope.Book@f8fae4

cn.itcast.h_annotation.d_scope.Book@f8fae4

 

@Scope("prototype")

cn.itcast.h_annotation.d_scope.Book@f8fae4

cn.itcast.h_annotation.d_scope.Book@1fc493

 

 

    1. Java类配置Bean

测试

package cn.itcast.h_annotation.e_class_config;

 

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import org.springframework.context.annotation.Configuration;

 

public class App {

  

   public static void main(String[] args) {

     

      //用于加载使用@Configuration 配置注解工厂类

      AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

      //用于向 注解上下文对象 添加一个配置类

      context.register(BeanConfig.class);

      //刷新容器以应用这些注册的配置类

      context.refresh();

     

      UserDao userDao = (UserDao) context.getBean("userDao");

      System.out.println(userDao);

     

      BookDao bookDao = context.getBean("myBookDao", BookDao.class);

      System.out.println(bookDao);

   }

 

}

 

配置类

 

package cn.itcast.h_annotation.e_class_config;

 

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

 

@Configuration

public class BeanConfig {

  

   @Bean

   public UserDao userDao(){

      return new UserDao();

   }

  

   @Bean(name="myBookDao")

   public BookDao bookDao(){

      return new BookDao();

   }

 

}

 

 

package cn.itcast.h_annotation.e_class_config;

 

public class UserDao {

 

}

 

 

 

package cn.itcast.h_annotation.e_class_config;

 

public class BookDao {

 

}

 

 

 

结果：

cn.itcast.h_annotation.e_class_config.UserDao@145315

cn.itcast.h_annotation.e_class_config.BookDao@5aa997

 

 

 

 

  1. Web开发应用Spring
    1. 导入jar包

 

    1. 配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="3.0"

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  

   <!-- 设置给监听器xml配置文件的位置

      classpath： 表示src下

      直接写：表示WEB-INF下

   -->

   <context-param>

      <param-name>contextConfigLocation</param-name>

      <param-value>classpath:applicationContext.xml</param-value>

   </context-param>

  

   <!-- 配置spring提供的监听器，加载 xml配置文件 -->

   <listener>

      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

   </listener>

  

  <servlet>

    <servlet-name>HelloServlet</servlet-name>

    <servlet-class>cn.itcast.servlet.HelloServlet</servlet-class>

  </servlet>

 

  <servlet-mapping>

    <servlet-name>HelloServlet</servlet-name>

    <url-pattern>/servlet/HelloServlet</url-pattern>

  </servlet-mapping> 

</web-app>

 

 

 

    1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                          http://www.springframework.org/schema/beans/spring-beans.xsd

                          http://www.springframework.org/schema/context

                          http://www.springframework.org/schema/context/spring-context.xsd">

   <bean id="helloService" class="cn.itcast.service.HelloService"></bean>

 

</beans>

 

 

 

    1. Servlet操作

package cn.itcast.servlet;

 

import java.io.IOException;

 

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

 

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

 

import cn.itcast.service.HelloService;

 

public class HelloServlet extends HttpServlet {

 

   public void doGet(HttpServletRequest request, HttpServletResponse response)

          throws ServletException, IOException {

      this.doPost(request, response);

   }

 

   public void doPost(HttpServletRequest request, HttpServletResponse response)

          throws ServletException, IOException {

     

      //第一种方式获得

      WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());

      HelloService helloService =  (HelloService) webApplicationContext.getBean("helloService");

      System.out.println(helloService);

     

      //第二种方式

      WebApplicationContext webApplicationContext2 = (WebApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

      HelloService helloService2 =  (HelloService) webApplicationContext2.getBean("helloService");

      System.out.println(helloService2);

 

   }

 

}

 

 

    1. Service

package cn.itcast.service;

 

public class HelloService {

 

}

 

 

  1. Spring整合Junit注解开发

 

    1. 导入jar包

 

    1. Service类

package cn.itcast.a_junit;

 

 

public class UserService {

 

   public void login(){

      System.out.println("service login");

   }

 

}

 

 

    1. Spring容器

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

                http://www.springframework.org/schema/beans/spring-beans.xsd">

      

    <bean id="user" class="cn.itcast.a_junit.UserService">

    </bean> 

</beans>

 

 

    1. 测试类编写

 

package cn.itcast.a_junit;

 

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 

 

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations="classpath:cn/itcast/a_junit/beans.xml")   //从src开始获得指定位置的xml

//@ContextConfiguration(locations="beans.xml")  //从当前目录获得xml配置文件

public class App {

  

   @Autowired

   public UserService userService;

  

   @Test

   public void demo(){

      userService.login();

   }

 

}

 

 [lt1]此时肯定使用的是“构造1”方法

 [lt2]需要导入约束

 [lt3]

p:属性 进行内容注入

操作简单

猜你喜欢

转载自blog.csdn.net/majiawenzzz/article/details/81103675
今日推荐
周排行
AIZU 2224 Save your cats(并查集)
HTTP响应头状态码详解
Python socket编程（2）
MaxCompute Studio使用心得系列7—作业对比
Supervisor安装使用
LeetCode 164. Maximum Gap
mysql面试题: 一张表里面有ID自增主键，当insert了17条记录之后，删除了第15,16,17条记录，再把mysql重启，再insert一条记录，这条记录的ID是18还是15
nutch1.2 DeleteDuplicates IndexMerger 详解
OC - @property与setter,getter方法
SpringBoot @Transactional的rollbackFor属性
每日归档
更多
2024-09-19(0)
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022