Spring IOC/DI

最新推荐文章于 2024-08-08 18:50:33 发布

LuckyDeLee

最新推荐文章于 2024-08-08 18:50:33 发布

阅读量311

点赞数 1

分类专栏：框架文章标签： spring ioc

本文链接：https://blog.csdn.net/qq_29747683/article/details/78495620

版权

框架专栏收录该内容

4 篇文章 0 订阅

订阅专栏

简介

SpringIOC可以帮我们完成对象的创建，以及给对象的属性赋值。
SpringIOC的设计出发点是最大化降低对象之间的关系（耦合度），提高代码的可重用性和可移植性。

IOC(Inversion of Control)控制反转的简称。以前我们经常用new来创建对象，并用setter方法设置对象与对象之间的依赖关系（例如一个学生对象student和一个老师对象teacher，我们通过student.setTeacher(teacher)绑定老师和学生对象之间的关系），坏处：对象和类（接口）、对象和对象之间太强的耦合关系。而IOC的本质就是存放那些对象创建、赋值放到IOC容器，在IOC容器中进行对象之间的依赖关系注入（DI）。IOC容器负责管理对象之间的依赖管理。

IOC容器获取

new出来的对象依赖于具体类，通过工厂模式获取对象依赖工厂。
实体类：

public interface ICourse
{
 public abstract void learn();
}

public class JavaCourse implements ICourse
{
 @Override
 public void learn()
 {
  System.out.println("学习JAVA课程");
 }
}
public class OracleCourse implements ICourse
{
 @Override
 public void learn()
 {
  System.out.println("学习Oracle课程");
 }
}

一、对象的创建放到Spring配置文件（applicatoinContext.xml）中进行。如果需要使用对象，只需要现在Spring配置此对象（SpringIOC容器会帮助我们自动创建对象），然后直接从SpringIOC容器获取.
例如：

applicatoinContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans …>
     …
     <bean id="javaCourse" class="org.lzy.iocinstance.JavaCourse">
     </bean>

     <bean id="oracleCourse" 
    class="org.lzy.iocinstance.OracleCourse">
     </bean>
    </beans>

配置后,SpringIOC容器会替我们自动创建这两个对象（根据class值所代表的类型，创建相应的对象，并用id来标识该对象）。以后要使用两个对象时，可以通过ApplicationContext对象的getBean（）方法，根据标识符的id，直接从SpringIOC容器获取。
如：
Student.java



public class Student
{
 // 通过参数给getBean()方法传入不同的id值 来获取不同的课程对象
 public void learnCourse()
 {
  ApplicationContext context 
= new ClassPathXmlApplicationContext("applicatoinContext.xml");
  ICourse course =(ICourse)context.getBean("oracleCourse");
  course.learn();
 }
}

SpringIOC容器的本质就是一个大工厂，交给Spring去维护，我们需要做就是Spring配置文件进行对象配置，然后通过getBean（）方法从SpringIOC容器中获取。

控制反转：“控制”（对象创建）从Student类转移到SpringIOC容器。

依赖注入

DI：将SpringIOC容器中的资源，注入到某些对象之中。
实体类：

public class Teacher
{
 private String name ;
 private int age ;
 //省略setter、getter
}

public class Course
{
 private String courseName; //课程名
 private int courseHours; //课时
 private Teacher teacher; //授课老师
 //省略setter、getter
 public void showInfo()
 {
  System.out.println("课程名："+courseName+"\t课时：
"+courseHours+"\t\t授课老师："+teacher.getName());
 }
}

applicatoinContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans …>
     <bean id="teacher" class="org.lzy.dicinstance.Teacher">
      <property name="name" value="李四"></property>
      <property name="age" value="20"></property>
     </bean>
     <bean id="course" class="org.lzy.diinstance.Course">
      <property name="courseName" value="JAVA"></property>
      <property name="courseHours" value="100"></property>
      <property name="teacher" ref="teacher"></property>
     </bean> 
    </beans>

属性	简介
value	给name所表示的“简单类型”的属性赋值（如String、int）
ref	给name所表示的自定义类型的对象赋值（如Teacher类型的属性)。ref的值是另一个`<bean>`的id值，从而实现多个`<bean>`之间相互引用、相互依赖的关系

DI:SpringIOC容器不仅通过<property>的value属性，给String courseName、 int courseHours这些类型的属性赋值，而且还可以通过<property>的ref属性，给Teacher teacher这种类型对象也赋值。对象的值是通过SpringIOC容器注入进去。即依赖注入.

依赖注入的方式

常见的三种依赖注入方式:setter注入、构造器注入、p命名空间注入
（1）setter注入
本质通过反射机制，调用对象的setter方法，对属性进行赋值操作：

<bean id="course" class="org.lzy.diinstance.Course">
  <property name="courseName" value="JAVA"></property>
  <property name="teacher" ref="teacher"></property>
        …
</bean>

在Course对象中寻找setCourseName()方法，如果存在，则将<property>中的value的值“java”传入参数中，即调用对象的setter方法进行赋值。如果不存在该方法，则产生异常。
采用value或ref 这种setter方式给属性赋值，需有相应的setter方法。

（2）构造器注入
注意：手工编写有参构造方法后，JVM不在提供默认的无参构造方法，需编写。
applicationContext.xml

<bean id="teacher" class="org.lzy.diinstance.Teacher">
         <!—-给构造方法的第0个参数赋值-->
  <constructor-arg value="zy"></constructor-arg>
         <!—-给构造方法的第1个参数赋值-->
  <constructor-arg value="22"></constructor-arg>
 </bean>

<constructor-arg>顺序和构造方法中参数的顺序一致。
不一致，可用index或name属性指定
①使用index来指定参数的位置索引

<bean id="teacher" class="org.lzy.diinstance.Teacher">
    <!—-通过index属性，指定给构造方法中的第1个参数赋值-->
 <constructor-arg value="22" index="1"></constructor-arg>
    <!—-通过index属性，指定给构造方法中的第0个参数赋值-->
 <constructor-arg value="zy" index="0"></constructor-arg>
</bean>

②使用name属性来指定参数的属性名

<bean id="teacher" class="org.lzy.diinstance.Teacher">
    <!—-通过name属性，指定给构造方法中的“age”参数赋值-->
 <constructor-arg value="22" name="age"></constructor-arg>
    <!—-通过name属性，指定给构造方法中的“name”参数赋值-->
 <constructor-arg value="zy" name="name"></constructor-arg>
</bean>

如果A类有String str和int num两个属性，并且只有以下两个构造方法，public A(String str){…}和public A(int num) {…}，该如何通过构造方法赋值？
例子：

<bean id="a" class="A">
 <constructor-arg value="123" ></constructor-arg>
</bean>

说明：Spring无法知道”123”是String类型还是int类型（Spiring将所有“简单类型”的变量值，都写在value值的双引号中）。
解决方法<constructor-arg>标签中的name或type属性解决。
①使用name属性来指定参数的属性名。
②使用type属性来指定参数值的类型。如下，

bean id="a" class="A">
 <constructor-arg  value="123"  type="java.lang.String">
</constructor-arg>
</bean>

(3)p命名空间注入
必须在spring配置文件中引入“p命名空间”即xmlns:p=”http://www.springframework.org/schema/p”
例子

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 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">
 <bean id="…" …>
</beans>

p命名空间注入的特点：直接使用“p”给对象属性赋值，简化配置代码。

<bean id="teacher" class="org.lzy.diinstance.Teacher" 
p:name="zy" p:age="22">
</bean>
<bean id="course" class="org.lzy.diinstance.Course" 
     p:courseName="JAVA" 
  p:courseHours="680" p:teacher-ref="teacher"> 
</bean>

注入各种数据类型的属性

Spring提供了不同的标签来实现不同类型参数的注入
（1）使用setter设置注入方式，注入各种类型的属性
①注入“简单类型”的属性值

<bean id="teacher" class="org.lzy.dinstance.Teacher">
  <!-- 使用子元素<value>注入 -->
  <property name="name">
   <value type="java.lang.String">lzy</value> 
  </property>
  <!-- 使用value属性注入 -->
  <property name="age" value="22"></property>
</bean>

两种注入参数值方式的区别

	使用子元素`<value>`注入	而使用value属性注入
参数位置	写在首尾标签（`<value></value>`）的中间(不加双引号)	写在value的属性值中（必须加双引号）
type属性	有（可选）可以通过type属性指定数据类型	无
参数值包含特殊字符（<， &）时的处理方法	两种处理方法。一、使用`<![CDATA[　　]]>`标记二、使用XML预定义的实体引用	一种处理方法。即使用XML预定义的实体引用

其中,XML预定义的实体引用，如下：

实体引用	表示的符号
&It;	<
&	&

示例：

    <bean id="student" class="org.lzy.entity.Student">
     <property name="stuName">
      <value><![CDATA[张&三]]></value>
    </property>
    </bean>
 或
     <bean id="student" class="org.lzy.entity.Student">
     <property name="stuName">
       <value>张&amp;三</value>
      </property>
    </bean>
    或
        <bean id="student" class="org.lzy.entity.Student">
     <property name="stuName" value="张&amp;三"></property>
    </bean>

给Student对象的stuName属性赋值为”张&;三”
②输入对象类型的属性值
使用<ref>属性以外，还可以使用<ref>子元素：

    <bean id="course" class="org.lzy.diinstance.Course">
    …
      <property name="teacher" >
        <ref bean="teacher"/>
      </property>
    </bean>

通过<ref>子元素的bean属性，来指定需要引用的<bean>的id值（即需要引用的对象）

特殊情况：如果需要引用的对象仅仅只需要使用一次，则可以使用“内部Bean”的方式来引用（类似于JAVA的“内部类”），如下：

    <bean id="course" class="org.lzy.diinstance.Course">
      …
      <property name="teacher" >
       <bean class="org.lzy.diinstance.Teacher">
        <property name="name" value="lzy"></property>
        <property name="age" value="22" ></property>
       </bean>
      </property>
    </bean>

以上，就是使用“内部Bean”的方式，给Course对象注入了一个Teacher类型的属性。ps：“内部Bean”Teacher类所在的中并没有“id”属性。

③注入集合类型的属性值
对于集合或数组类型的属性，我们可以使用如下标签来注入属性值

类型	使用的标签
List或数组	外层用`<list>`:内层用`<value>或<ref>`
Set	外层用`<set>`:内层用`<value>或<ref>`
Map	外层用`<map>`:中间层用`<entry>`;内层中键用`<key><value>…</value></key>`，值用`<value>…</value>`或`<ref>…</ref>`
Properties	外层用`<props>`；内层中键写在`<prop key=”..”>..</prop>`的key值中，值写在`<prop>..</prop>`中间。Properties中的键和值通常都是字符串类型。

具体示例如下：
AllConnectionType.java 包含各种集合类型的属性

public class AllConnectionType {
    private List<String> list;
 private String[] array;
 private Set<String> set;
 private Map<String, String> map;
 private Properties props;
//省略setter、getter   
//输出所有属性值
public void showInfo()
 {
  System.out.println("List属性：" + this.list);
  System.out.print("数组属性：");
  for (String arr : this.array)
  {
   System.out.print(arr+"\t");
  } 
  System.out.println("\nSet属性：" + this.set);
  System.out.println("Map属性：" + this.map);
  System.out.println("Properties属性：" + this.props);
 }
}

通过配置文件，注入全部的属性值，如下
applicationContext.xml

    <bean id="connType" class="org.lanqiao.test.AllConnectionType" >
      <!-- 注入List类型 -->
      <property name="list">
       <list>
        <!-- 定义List中的元素 -->
        <value>苹果</value>
        <value>橘子</value>
       </list>
      </property>
      <!-- 注入数组类型 -->
      <property name="array">
       <list>
        <!-- 定义数组中的元素 -->
        <value>苹果</value>
        <value>橘子</value>
       </list>
      </property>
      <!-- 注入Set类型 -->
      <property name="set">
       <list>
        <!-- 定义Set或数组中的元素 -->
        <value>苹果</value>
        <value>橘子</value>
       </list>
      </property>
      <!-- 注入Map类型 -->
      <property name="map">
       <map>
        <!-- 定义Map中的键值对 -->
        <entry>
         <key>
          <value>apple</value>
         </key>
         <value>苹果</value>
        </entry>
        <entry>
         <key>
          <value>orange</value>
         </key>
         <value>橘子</value>
        </entry>
       </map>
      </property>
      <!-- 注入Properties类型 -->
      <property name="props">
       <props>
        <!-- 定义Properties中的键值对 -->
        <prop key="apple">苹果</prop>
        <prop key="orange">橘子</prop>
       </props>
      </property>
     </bean>
如果集合的属性值包含对象类型，只需要把<value>改成<ref bean=""/>.

④注入null和空字符串

注入的值	使用的标签
空字符串(如String comment = “”)	`<value></value>`，即在`<value>`标签中不写任何值
null(如Teacher =null)	`<null>`

表示给Course对象的courseName属性赋值为空字符串，给teacher属性赋值为null

    <bean id="course" class="org.lzy.diinstance.Course">
        <property name="courseName">
       <value></value>
      </property>     
      <property name="teacher" ><null/></property>
    </bean>

使用“构造器注入”方式，注入各种类型的属性
与 “setter设置注入”方式类似，只需要把上述<list>、<map>、< props >等标签放入<constructor-age>和</constructor-age>中间即可。

自动装配

使用IOC/DI后，对象与对象之间的关系是通过配置文件（ref属性）组织在一起，而不再是通过硬编码的方式耦合在一起了。弊端：需要额外编写大量配置文件。为了简化配置，可以使用Mybatis中“约定优于配置”原则。“自动装配”，适用对象类型（引用类型）的属性（即通过ref属性注入的<Bean>与<Bean>之间的关系），而不适用简单类型（基本类型和String类型）。

applicationContext.xml
setter设值注入

     <bean id="teacher" class="org.lzy.diinstance.Teacher" >
      …
     </bean>
     <bean id="course" class="org.lzy.diinstance.Course">
       … 
       <property name="courseHours" value="680"></property>
       <property name="teacher" ref="teacher"></property>
     </bean>

具体就是通过value为“简单类型”赋值，通过ref为对象类型赋值。而如果事先遵循一定的“约定”，就可以省略id为“course”的<bean>中，使用<property>为对象类型(Teacher对象)赋值的过程。

根据属性名自动装配

    <bean id="teacher" class="org.lzy.diinstance.Teacher" >
     …
    </bean>
    <bean id="course" class="org.lzy.diinstance.Course" 
    autowire="byName" />

给id=”course”的<bean>中，加上 autowire=”byName”，就是为了告诉Spring这个<bean>符合一定的“约定”，可以自动为对象类型的属性（即teacher）赋值。之后，Spring就会自动在其他<bean>中，寻找id值与属性名“teacher”一致的<bean>。如果找到，就会将找到的<bean>注入到teacher属性之中，这就是根据“属性名”自动装配的约定。

通过autowire属性值来指定具体方式

autowrite属性值	自动装配方式
no	不使用自动装配。必须通过`<property>`的ref属性来指定对象之间的依赖关系。
byName	根据属性名自动装配。如果某一个`<bean>`的id值，与当前`<bean>`的某一个属性名相同，则自动注入；如果没有找到，则什么也不做。（本质是寻找属性名的setter方法）
byType	根据属性类型自动装配。如果某一个`<bean>`的类型，恰好与当前`<bean>`的某一个属性的类型相同，则主动注入；如果有多个 `<bean>`的类型都与当前`<bean>`的某一个属性的类型相同，则Spring将无法决定注入哪一个`<bean>`，就会抛出一个异常；如果没有找到，则什么也不做。
constructor	根据构造器自动装配。与byType类似，区别是它需要使用构造方法。如果Spring没有找到与构造方法参数列表一致的`<bean>`，则会抛出异常。

根据属性类型自动装配

    <bean id="teacher" class="org.lzy.diinstance.Teacher" >
     …
    </bean>
    <bean id="course" class="org.lzy.diinstance.Course" 
    autowire="byType" />

autowire设置为“byType”以后，Spring就会在其他所有<bean>中，寻找与Course中的teacher属性类型相同的<bean>（即找Teacher类型的<bean>），找到之后就会自动注入给teacher属性。

根据构造器自动装配

    <bean id="teacher" class="org.lzy.diinstance.Teacher" >
     …
    </bean>
    <bean id="course" class="org.lzy.diinstance.Course" 
    autowire="constructor" />

使用构造器自动装配，必须在Course类中先提供相应的构造方法。比如，本例是想通过构造方法，给Course类中的teacher属性赋值，则就必须在Course类中提供以下构造方法，

Course.java

public class Course
{
    …
 private Teacher teacher;
 public Course(Teacher teacher)
 {
  this.teacher = teacher;
 }
…
}

说明：
1.如果配置文件中所有的<bean>都要使用自动装配，则除了在每一个<bean>中设置autowire属性以外，还可以设置一个全局的“default-autowire”，用于给所有的<bean>都注册一个默认的自动装配类型。设置方法是在配置文件里，<beans>的属性中加入“default-autowire”属性，如下，

    <beans xmlns="…"
      xmlns:xsi="…" 
         xmlns:p="…"
          xsi:schemaLocation="…"
          default-autowire="byName">
             <bean …> …</bean>
              …
    </beans>

表示给所有的<bean>都设置成了“根据属性名自动装配”。当然，设置全局的“default-autowire”以后，还可以在单独的<bean>中再次设置自己的“autowire”用来覆盖全局设置。

2．我们虽然可以通过自动装配，来减少Spring的配置编码。但是过多的自动装配，会降低程序的可读性。因此，对于大型的项目来说，并不鼓励使用自动装配。

三种自动装配的可读性为：byName>byType>constructor

基于注解形式IoC配置

对于Dao层、Service层、Contoller层中的类，还可以通过注解的形式来实现Spring IoC。

使用注解定义Bean

StudentDaoImpl.java

    import org.springframework.stereotype.Component;
    @Component("studentDao")
    public class StudentDaoImpl implements IStudentDao
    {
     @Override
     public void addStudent(Student student)
     {
      System.out.println("模拟增加学生操作...");
     }
    }

以上通过@Component定义了一个名为studentDao的Bean，@Component(“studentDao”)的作用等价于XML形式的<bean id="studentDao" class="org.lanqiao.dao.StudentDaoImpl" />。

@Component可以作用在DAO层、Service层、Controller层等任一层的类中，范围较广。此外，还可以使用以下3个细化的注解：

注解	范围
@Repository	用于标注DAO层的类
@Service	用于标注Service层的类
@Controller	用于标注Controller层的类

使用注解实现自动装配

可以使用@Autowrited注解实现多个Bean之间的自动装配：

    @Service("studentService")
    public class StudentServiceImpl implements IStudentService
    {
        //@Autowired标识的属性，默认会按“属性类型”自动装配
     @Autowired
     private IStudentDao studentDao ;

     public void setStudentDao(IStudentDao studentDao)
     {
      this.studentDao = studentDao;
     }
     @Override
     public void addStudent(Student student)
     {
      studentDao.addStudent(student);
     }
    }

通过@Service标识了一个业务Bean,并且使用Autowired为studentDao属性自动装配。@Autowired默认采用按“属性类型”自动装配，可以通过@Qualifier设置为按“属性名”自动装配，如下：

    @Service("studentService")
    public class StudentServiceImpl implements IStudentService
    {
         //指定@Autowired标识的属性，按“属性名”自动装配
     @Autowired
     @Qualifier("studentDao")
     private IStudentDao studentDao ;
     …
    }

@Autowired除了可以对属性标识以外，还可以对setter方法进行标识，作用与对属性标识是相同的，如下：

    @Service("studentService")
    public class StudentServiceImpl implements IStudentService
    {
     private IStudentDao studentDao ;
     @Autowired
     public void setStudentDao(IStudentDao studentDao)
     {
      this.studentDao = studentDao;
     }
       …
    }

扫描注解定义的Bean

使用@Controller、@Service、@Repository、@Component等标识完类(Bean)以后，还需要将这些类所在的包通过component-scan扫描后才能加载到Spring IoC容器之中，如下：

    <beans…>
    <context:component-scan base-package="org.lzy.dao,
    org.lzy.service">
    </context:component-scan>
    </beans>

通过base-package属性指定需要扫描的基准包是org.lzy.dao和org.lzy.service，之后Spring就会扫描这两个包中的所有类（含子包中的类），将其中用@Service等标识的类加入到SpringIoC容器之中。此处在定义扫描包时用到了context，所以在使用前需要导入context命名空间

使用注解实现事务

@Transactional注解在Spring中配置声明式事务,需导入一下jar包：

spring-tx-4.2.5.RELEASE.jar	ojdbc6.jar	commons-dbcp-1.4.jar
commons-pool-1.6.jar	spring-jdbc-4.2.5.RELEASE.jar	aopalliance.jar

并在Sring配置文件中配置数据源、事务管理类，以及添加对注解配置事务的支持：

    <beans…>
        …
     <!-- 配置数据源 -->
     <bean id="dataSource" 
    class="org.apache.commons.dbcp.BasicDataSource" 
    destroy-method="close">
       <property name="driverClassName" 
    value="oracle.jdbc.OracleDriver"/>
       <property name="url" 
    value="jdbc:oracle:thin:@127.0.0.1:1521:XE"/>
       <property name="username" value="system"/>
       <property name="password" value="123"/>
       <property name="maxActive" value="10"/>
       <property name="maxIdle" value="5"/>
     </bean> 
     <!-- 配置事务管理类 -->
     <bean id="txManager" 
    class="org.springframework.jdbc.datasource
    .DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
     </bean>
     <!-- 增加对注解配置事务的支持 -->
     <tx:annotation-driven transaction-manager="txManager" />
    </beans>

程序中使用@Transactional来配置事务

@Service("studentService")
public class StudentServiceImpl implements IStudentService
{
 …
 @Transactional(readOnly=false,
propagation=Propagation.REQUIRES_NEW)
 @Override
 public void addStudent(Student student)
 {
  studentDao.addStudent(student);
 }
}

@Transactional的常用属性：

属性	类型	说明
propagation	枚举型：Propagation	（可选）事务传播行为。例如：propagation=Propagation.REQUIRES_NEW
readOnly	布尔型	是否为只读型事务。例如：readOnly=false
isolation	枚举型：isolation	（可选）事务隔离级别。例如：isolation=Isolation.READ_COMMITTED
timeout	int型（单位：秒）	事务超时时间。例如：timeout=20
rollbackFor	一组Class类的实例，必须继承自Throwable	一组异常类，遇到时必须进行回滚。例如：rollbackFor={SQLException.class,ArithmeticException.class}
rollbackForClassName	一组Class类的名称，必须继承自Throwable	一组异常类名，遇到时必须进行回滚。例如：rollbackForClassName={“SQLException”,”ArithmeticException”}
noRollbackFor	一组Class类的实例，必须继承自Throwable	一组异常类，遇到时必须不回滚
noRollbackForClassName	一组Class类的名称，必须继承自Throwable	一组异常类名，遇到时必须不回滚