Spring02-注入和注解方式操作

2021-07-08 17:05

阅读：340

标签：ons common getbean control express ide 出现 type属性 autowired

一. 依赖注入

测试类:Person.java

创建配置文件：applicationContext-injection.xml

创建测试代码：InjectionTest.java

1. set方法注入

1.1 基本类型值注入使用value

配置:

1   
2   class="spring.bean.Person" >
3        4        5

测试代码:

 1   @Test
 2   public  void  test1(){
 3         //TODO 测试基本数据类型注入数据
 4         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
 5 
 6         Person person = context.getBean("person", Person.class);
 7 
 8         System.out.println("person = " + person);
 9         //输出结果:------------> Person.Person
10         //          person = Person{name=‘jeck‘, age=11}
11  }

1.2 引入类型值注入ref

创建 Car.java:

 1 public class Car {
 2     private String name;
 3     private String color;
 4     
 5     public Car() {
 6         super();
 7         System.out.println("Car的空参构造方法");
 8     }
 9     //getter、setter、toString
10 }

修改Person.java,在Person中引入Car:

1 public class Person {
2     private String name;
3     private Integer age;
4     private Car car;
5      //构造方法 getter setter toString方法 
6 }

配置:利用ref属性给 person的car属性赋值

 1   class="spring.bean.Person">
 2        3        4        5    6     
 7   class="spring.bean.Car">
 8        9       10

测试: 使用之前测试用例即可!

2.构造函数注入

2.1 单个有参构造方法注入

在Person中创建有参构造函数:

1  public  Person(String  name , Car car){
2         this.name = name;
3         this.car = car;
4         System.out.println("Person的有参构造方法:"+name+car);
5  }

配置:

1 class="spring.bean.Person">
2            3            4  5  
6  class="spring.bean.Car" >
7            8            9

测试:

 1   @Test
 2   public  void test2(){
 3         //TODO 测试参构造方法
 4         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
 5 
 6         Person person = context.getBean("person", Person.class);
 7 
 8         System.out.println(person);
 9         //结果:调用有参数构造方法,输出
10   }

2.2. index属性：按参数索引注入

参数名一致，但位置不一致时，使用 index

例如以下两个构造函数（第二个是新添加）：

 1     public Person(String name, Car car) {
 2         super();
 3         System.out.println("Person(String name, Car car)");
 4         this.name = name;
 5         this.car = car;
 6     }  
 7     public Person(Car car, String name) {
 8         super();
 9         System.out.println("Person(Car car, String name)");
10         this.name = name;
11         this.car = car;
12     }

配置：使用 index 确定调用哪个构造函数

1     class="spring.bean.Person">
2         3         4

测试：

重新执行第一步的测试用例，执行结果调用了第一个构造函数

2.3. type属性：按参数类型注入

参数名和位置一致，但类型不一致时，使用type

例如以下两个构造函数（第二个是新添加）：

 1     public Person(Car car, String name) {
 2         super();
 3         System.out.println("Person(Car car, String name)");
 4         this.name = name;
 5         this.car = car;
 6     }
 7   
 8     public Person(Car car, Integer name) {
 9         super();
10         System.out.println("Person(Car car, Integer name)");
11         this.name = name + "";
12         this.car = car;
13     }

配置：使用type指定参数的类型

    class="spring.bean.Person">

测试：

重新执行前面的测试用例，执行结果调用了第二个构造函数

3. p名称空间注入

导入p名称空间:

使用p:属性名完成注入,走set方法

基本类型值: p:属性名="值"
引入类型值: P:属性名-ref="bean名称"

配置:

 1 //1.第一步配置文件中 添加命名空间p 
 2  xmlns:p="http://www.springframework.org/schema/p"
 3  4        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 xmlns:p="http://www.springframework.org/schema/p"      xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">
 6        //使用 p命称空间进行赋值
 7         class="spring.bean.Person"  p:name="人名" p:age="11"    p:car-ref="car">
 8         9        class="spring.bean.Car" >
10            11            12

测试:

1 @Test
2 public  void test2(){
3     //TODO 测试p命名空间注入
4     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
5     Person person = context.getBean("person", Person.class);
6     System.out.println(person);
7     
8  }

4. spel注入

spring Expression Language：spring表达式语言

配置:

1   class="spring.bean.Car" >
2            3            4   5    
6    class="spring.bean.Person"  p:car-ref="car">
7             8             9

测试

1 @Test
2 public  void test3(){
3     //TODO 测试spel注入
4     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
5     Person person = context.getBean("person1", Person.class);
6     System.out.println(person);
7     
8  }

5. 复杂类型注入

创建配置文件:application-collection.xml

创建测试代码:CollectionTest.java

创建测试实体类:TestCollection

创建TestCollection:

 1 /**
 2  * 练习:arr list map properties的注入
 3  */
 4 public class TestCollection {
 5 
 6     private Object [] arrs;
 7     private List

配置:

 1  2  3        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        class="spring.bean.Car">
 5               6               7         8        class="pring.bean.TestCollection">
 9            
10            11                12                    数组113                    
14                    15                16            17            
18            19                 20                     集合121                     
22                     23                         集合中的集合124                         集合中的集合225                         集合中的集合326                     27                     28                 29            30 
31            
32            33                34                    35                    36                    37                38            39            
40            41                 42                     pro143                     11144                 45            46        47 
48

测试:

1  @Test
2  public  void  test4(){
3         //TODO 复杂类型注入练习
4      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-collection.xml");
5      TestCollection textColl = context.getBean("testColl", TestCollection.class);
6      System.out.println("testColl = " + textColl);
7 
8    }

二.使用注解

使用注解的方式完成IOC

1. 准备工作

创建项目: spring-02-annotation
导入jar包: spring-core,spring-context,spring-suppot-context,spring-beans,spring-expression, log4j,commons-logging,本次多加一个:spring-aop
引入日志配置文件:log4j.properties
实体类: 原项目 Person.java 和 Car.java即可
创建配置文件: applicationContext.xml
创建测试代码类:AnnotationTest.java

2. 使用注解

2.1 引入Context的约束

参考文件位置:spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html 40.2.8 the context schema

配置:

1 2 
3 4        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:context="http://www.springframework.org/schema/context"
5        xsi:schemaLocation="
6         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
7         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 
8

2.2 配置注解扫描

在applicationContext.xml中配置:

指定扫描 包 下所有类中的注解,扫描包时,会扫描包所有的子孙包.

 1  2 
 3  4        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"      xmlns:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="
 6         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">         
 8      
 9       package="spring.bean">       10

2.3 使用注解

在Person类的头部添加如下注解

 1 /**
 2   * @Component(person) ==  3   */
 4 
 5 @Component("person")
 6 public class Person {
 7     private String name;
 8     private Integer age;
 9     private Car car;
10     public  Person(){
11         System.out.println("无参数构造方法!");
12     }
13   //getter,setter,toString
14 }

测试:

1   @Test
2   public  void  test1(){
3      //TODO 测试注解入门
4      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
5      Person person = context.getBean("person", Person.class);
6      System.out.println("person = " + person);
7  }

3. 其他注解

介绍其他常用注解,测试方式同前

3.1 类头部可用的注解

1 @Service("person")         // service层
2 @Controller("person")     // controller层
3 @Repository("person")    // dao层

3.2 类头部可用的注解

指定对象作用域

1 @Scope(scopeName="singleton")
2 @Scope(scopeName="prototype")

3.3 注入属性value值

1.设置成员变量上:通过反射给变量赋值

1 @Value("name值")
2 private String name;

@Value("name值") 等同于 @Value(value="name值")

2.加在set方法上:通过set方法赋值

1 @Value("tom")
2 public void setName(String name)
3 {
4   this.name = name;
5 }

3.4 自动装配

@Autowired

使用 @Autowired 自动装配对象类型的属性: 下面的Person中的Car使用了自动装配

 1 //将Car定义成接口
 2 @Component
 3 public interface Car {
 4      void log();
 5 }
 6 //Baoma实现Car
 7 @Component
 8 public class Baoma implements Car {
 9     public void log() {
10         System.out.println("宝马");
11     }
12 }
13 //XianDai实现Car
14 @Component
15 public class XianDai implements Car {
16     public void log() {
17         System.out.println("现代");
18     }
19 }

装配类:

1 @Scope(scopeName = "prototype")
2 @Component("person")
3 public class Person {
4     @Value("name值")
5     private String name;
6     private Integer age;
7     @Autowired      
8     private Car car;  //自动装配 可以选择Car,如果Car是接口,找Car的实现类!

注意: 以上操作会出现一个问题,如果Car是接口,且Car只有一个实现类,那么@Autowired会自动将实现类装配给Person的car变量上,但是如果Car是接口,并且有两个以上实现类,那么自动装配就会报错,无法选择由哪个实现类赋值.所以需要配合另一个注释@Qualifier("bean name"), 这个属性可以将@Autowired按类型赋值改成按bean名字赋值.

3.5 @Qualifier

如果匹配多个类型一致的对象，将无法选择具体注入哪一个对象

使用@Qualifier()注解告诉spring容器自动装配哪个名称的对象。

1 @Scope(scopeName = "prototype")
2 @Component("person")
3 public class Person {
4     @Value("name值")
5     private String name;
6     private Integer age;
7     @Autowired  
8     @Qualifier("baoma")   //指定实现类
9     private Car car;  //自动装配 可以选择Car,如果Car是接口,找Car的实现类!

3.6 @Resource

@Resource 是java的注释,但是Spring框架支持,@Resource指定注入哪个名称的对象

@Resource("name") == @Autowired + @Qualifier("name")

1 @Resource(name="baoma") 
2 private Car car;

3.7 初始化和销毁方法

初始化和销毁方法等同于配置文件添加的init-method和destroy-method功能,

例:Person类中init方法和destroy方法添加如下注解:

1  @PostConstruct
2  public  void init(){
3    System.out.println("初始化方法");
4  }
5  @PreDestroy
6  public void destroy(){
7    System.out.println("销毁方法");
8  }

三. Spring整合JUnit测试

spring整合junit，为我们提供了方便的测试方式

1、导包：在spring-02-annotation项目中再加入如下包

spring-test-4.2.8.jar

2、创建测试类

 1 //创建容器
 2 @RunWith(SpringJUnit4ClassRunner.class)
 3 //指定创建容器时使用哪个配置文件
 4 @ContextConfiguration("classpath:applicationContext.xml")
 5 public class RunWithTest {
 6     //将名为user的对象注入到u变量中
 7     @Resource(name="person")
 8     private Person p;
 9     @Test
10     public void testCreatePerson(){
11         System.out.println(p);
12     }
13 }

Spring02-注入和注解方式操作

标签：ons common getbean control express ide 出现 type属性 autowired

原文地址：https://www.cnblogs.com/sueyyyy/p/9581833.html

上一篇：JavaScript 输出

下一篇：JavaScript 简介

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Spring02-注入和注解方式操作
文章链接：http://soscw.com/essay/102423.html

亲，登录后才可以留言！

Spring02-注入和注解方式操作

一. 依赖注入

二.使用注解

评论

热门文章

推荐文章

最新文章

置顶文章