知识

Spring: IOC & DI

张天宇 on 2020-03-04

Spring中的控制反转和依赖注入。

耦合与解耦

耦合：程序之间的依赖关系，包括类之间的依赖和方法中的依赖。

解耦：降低程序之间的依赖关系。

实际开发中应该做到：编译器不依赖，运行时才依赖。

解耦思路：

  • 1.使用反射来创建对象，避免使用new关键字。

  • 2.通过读取配置文件来读取要创建的对象全限定类名。

实例1：JDBC驱动注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//常规
//1.注册驱动(独立性差)
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//2.获取连接
Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/test"，"root"，"root");
//3.获取数据库的预处理对象
PreparedStatement pstm=conn.prepareStatement("select * from account");
//4.执行SQL语句，得到结果集
ResultSet rs=pstm.executeQuery();
//5.遍历结果集
while (rs.next()){
      System.out.println(rs.getString("name"));
}
//6.释放资源
rs.close();
pstm.close();
conn.close();
1
2
//通过反射加载驱动类
Class.forName("com.mysql.jdbc.Driver");

实例2：三层框架解耦

表现层调用业务层，业务层调用持久层。

1
2
3
4
5
6
public class Client {
    public static void main(String[] args) {
        IAccountService as=new AccountServiceImpl();
        as.saveAccount();
    }
}

业务层依赖持久层的接口和实现类，若编译时不存在没有持久层实现类，则编译期不能通过，造成了编译期依赖。

使用工厂模式解耦

Bean：在计算机英语中有可重用组件的含义。

JavaBean：用Java语言编写的可重用组件。不等于实体类，远大于实体类。

Bean工厂：创建service和dao对象。

  • 1.需要一个配置文件配置service和dao。配置文件内容：唯一标识=全限定类名(key-value)，xml或者properties。
  • 2.通过读取配置文件中的内容，反射创建对象。

在实际开发中可以把三层的对象的全类名都使用配置文件保存起来，当启动服务器应用加载的时候，创建这些对象的实例并保存在容器中。在获取对象时，不使用new的方式，而是直接从容器中获取，这就是工厂设计模式。

Spring中的IOC

降低程序间的耦合性（依赖关系）

Spring Framework Core：https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/core.html#spring-core

项目创建

  1. 创建Maven项目，配置pom.xml。
1
2
3
4
5
6
7
<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
</dependencies>

  1. 创建框架，三层接口类和实现类。

  2. 配置bean文件。XML格式，可通过上述文档查找：

1
2
3
4
5
6
7
8
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把对象的创建交给Spring来管理-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
</beans>
  1. 在表现层中通过容器创建对象，核心容器的getBean()方法获取具体对象。
1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
     public static void main(String[] args) {
         // 获取核心容器对象
         ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
         // 根据id获取Bean对象
         IAccountService as  = (IAccountService)ac.getBean("accountService");
         //或者不强转，传入字节码
         IAccountService as  = ac.getBean("accountService"， IAccountService.class);
         // 执行as的具体方法
         // ...
     }
 }

常用容器

  • ClassPathXmlApplicationContext: 它是从类的根路径下加载配置文件（常用）
  • FileSystemXmlApplicationContext: 它是从磁盘路径上加载配置文件（必须有访问权限）
  • AnnotationConfigApplicationContext: 读取注解创建容器

核心容器两个接口引发出的问题

  • ApplicationContext: 它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说一读取完配置文件马上创建配置文件中配置的对象。单例对象适用。
  • BeanFactory: 它在构建核心容器时，创建对象采取的策略是延迟加载的方式，也就是说什么时候根据ID获取对象了什么时候才真正的创建对象。多例对象适用。

Bean的细节

Bean实例化的三种方式

  • 使用默认无参构造函数创建对象：默认情况下会根据默认无参构造函数来创建类对象，若Bean类中没有默认无参构造函数，将会创建失败。

    1
    <bean id="accountService" class="cn.maoritian.service.impl.AccountServiceImpl"></bean>

  • 使用普通工厂的方法创建对象（使用某个类中的方法创建对象并存入Spring容器）：

    1
    2
    3
    4
    5
    6
    //工厂，即我们需要使用createAccountService()来实例化一个IAccountService
    public class InstanceFactory {
    	public IAccountService createAccountService(){
    		return new AccountServiceImpl();
    	}
    }

    先创建实例工厂对象instanceFactory，通过调用其createAccountService()方法创建对象。

    1
    2
    3
    4
    5
    6
    7
    8
    <bean id="instancFactory" class="cn.maoritian.factory.InstanceFactory"></bean>
    <bean id="accountService"
    	factory-bean="instancFactory"
    	factory-method="createAccountService"></bean>
    <!--
    	factory-bean属性: 指定实例工厂的id
    	factory-method属性: 指定实例工厂中生产对象的方法
    -->

  • 使用工厂的静态方法创建对象：

    1
    2
    3
    4
    5
    public class StaticFactory {
    	public static IAccountService createAccountService(){
    		return new AccountServiceImpl();
    	}
    }

    使用StaticFactory中的静态方法createAccountServic()创建对象。

    1
    <bean id="accountService" class="cn.maoritian.factory.StaticFactory" factory-method="createAccountService"></bean>
Bean的作用范围和生存周期
单例对象
1
<bean id="accountService" class="cn.maoritian.factory.StaticFactory" factory-method="createAccountService" scope="singleton"></bean>
  • 出生：当容器创建时对象出生
  • 活着：只要容器还在，对象一直活着
  • 死亡：容器销毁，对象消亡
  • 总结：单例对象的生命周期和容器相同
多例对象
1
<bean id="accountService" class="cn.maoritian.factory.StaticFactory" factory-method="createAccountService" scope="prototype"></bean>
  • 出生：当使用对象时，Spring框架创建
  • 活着：对象在使用过程中一直活着
  • 死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收
Bean标签

配置托管给spring的对象，默认情况下调用类的无参构造函数，如果没有无参构造函数则创建失败。

  • id：指定对象在容器中的标识，将其作为参数传入getBean()方法可以获取获取对应对象。
  • class：指定类的全类名，默认情况下调用无参构造函数。
  • scope：指定对象的作用范围，可选值：
    • singleton：单例对象，默认值
    • prototype：多例对象
    • request：将对象存入到web项目的request域中
    • session：将对象存入到web项目的session域中
    • global session：将对象存入到web项目集群的session域中，若不存在集群，则global session相当于session
  • init-method：指定类中的初始化方法名称，在对象创建成功之后执行
  • destroy-method：指定类中销毁方法名称，对prototype多例对象没有作用，因为多利对象的销毁时机不受容器控制

Spring中的DI

依赖关系的维护，叫依赖注入。

注入的数据

  • 基本类型和String（经常变化的数据并不适用注入的方式，如数据库的账号和密码）
  • 其他Bean类型（在配置文件中或者注释配置过的Bean）
  • 复杂类型/集合类型

注入的方式

  • 使用构造函数注入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //对有参构造函数进行注入
    public class AccountServiceImpl implements IAccountService{
        private String name;
        private Integer age;
        private Date birthday;

        public AccountServiceImpl(String name, Integer age, Date birthday) {
            this.name = name;
            this.age = age;
            this.birthday = birthday;
        }

        public void saveAccount() {
            System.out.println("service中save"+name+","+age+","+birthday);
        }
    }

    使用的标签constructor-arg，属性有：

    • type：指定要注入的数据类型，该数据类型同时也是构造函数中某个或者某些参数的类型
    • index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，从0开始
    • name：用于指定给构造函数中指定名称的参数赋值（常用）
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的Bean类型数据，在Spring的IOC核心容器中出现过的Bean对象
    1
    2
    3
    4
    5
    6
    7
    <bean id="accountService" class="factory.service.AccountServiceImpl">
         <constructor-arg name="name" value="test"></constructor-arg>
         <constructor-arg name="age" value="15"></constructor-arg>
         <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!-- 配置一个Bean -->
    <bean id="now" class="java.util.Date"></bean>

    优势：在获取Bean对象时，注入数据是必须的，否则无法创建成功。

    弊端：改变了Bean对象的实例化方式，使我们在创建对象时，用不到这些数据也必须提供。

    在无可奈何时候才使用。

  • 使用Set方法注入（更常用）

    使用的标签property，属性有：

    • name：用于指定注入时所调用的Set方法名称
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的Bean类型数据，在Spring的IOC核心容器中出现过的Bean对象
    1
    2
    3
    4
    5
    6
    <!-- name后面接setter函数名字，如setUsername的username，与变量名无关 -->
    <bean id="accountService2" class="factory.service.AccountServiceImpl2">
        <property name="name" value="test"></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>

    优势：创建对象时没有明确的限制，可以直接使用默认构造函数。

    弊端：如果有某个成员必须有值，但获取对象时set方法没有执行。

    注入集合数据：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    public class AccountServiceImpl3 implements IAccountService{
        private String[] myStrs;
        private List<String> myList;
        private Set<String> mySet;
        private Map<String,String> myMap;
        private Properties myProps;

        public void setMyStrs(String[] myStrs) {
            this.myStrs = myStrs;
        }

        public void setMyList(List<String> myList) {
            this.myList = myList;
        }

        public void setMySet(Set<String> mySet) {
            this.mySet = mySet;
        }

        public void setMyMap(Map<String, String> myMap) {
            this.myMap = myMap;
        }

        public void setMyProps(Properties myProps) {
            this.myProps = myProps;
        }

        public void saveAccount() {
            System.out.println(Arrays.toString(myStrs));
            System.out.println(myList);
            System.out.println(mySet);
            System.out.println(myMap);
            System.out.println(myProps);
        }
    }

    用于给List结构集合注入的标签：list, array, set

    用于Map结构集合注入的标签：map, props

    结构相同，标签可以互换。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    <bean id="accountService3" class="factory.service.AccountServiceImpl3">
            <property name="myStrs">
                <array>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </array>
            </property>
            <property name="myList">
                <list>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </list>
            </property>
            <property name="mySet">
                <set>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </set>
            </property>
            <property name="myMap">
                <map>
                    <entry key="testaA" value="aaa"></entry>
                    <entry key="testB">
                        <value>bbb</value>
                    </entry>
                </map>
            </property>
            <property name="myProps">
                <props>
                    <prop key="testC">ccc</prop>
                    <prop key="testD">ddd</prop>
                </props>
            </property>
        </bean>

  • 使用注解提供

基于注解的IOC配置

注解和XML的选择原则：使用哪个最方便就是用哪种。

配置bean.xml

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="factory"></context:component-scan>
</beans>

配置标签

  • 用于创建对象

    @Component：把当前类对象存入Spring容器中。属性value用于指定bean的id，不写时默认当前类名首字母改小写。

    以下三个注解的作用和属性和Component一模一样，为Spring框架提供的明确的三层使用的注释，使三层对象更加清晰。

    @Controller：一般用在表现层

    @Service：一般用在业务层

    @Repository：一般用在持久层

  • 用于注入对象

    @Autowired：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以诸如成功。出现位置可以是成员变量，也可以是方法上。如果IOC有多个类型匹配时，首先按照类型框定匹配的对象，再按照变量名称作为bean的id继续查找，如果有一样的也可以注入成功，没有注入失败。使用注解时，set方法不是必须的。

    @Qualifier：在按照类中注入的基础上再按照名称注入。它在给类成员注入时不能单独使用要和@Autowired配合使用，但是给方法参数注入时可以。value用于指定注入bean的id。

    @Resource：直接按照bean的id注入，可以直接使用，不依托@Autowired使用。name用于指定注入的bean的id。

    以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。此外，集合类型的注入只能通过XML来实现。

    @Value：用于注入基本类型和String类型的数据。属性value用于指定数据的值，可以使用Spring中的SpEL，即Spring的el表达式(${表达式})。

  • 用于改变作用范围

    @Scope：用于指定bean的作用范围。属性value指定范围的取值，常用取值：singleton和prototype。

  • 和生命周期相关

    @PreDestroy：指定销毁方法。

    @PostConstruct：指定初始化方法。

示例：

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="factory"></context:component-scan>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Repository
public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}
@Service
public class AccountServiceImpl implements IAccountService{
    @Resource(name="accountDaoImpl")
    private IAccountDao accountDao;
    public void saveAccount() {
        accountDao.saveAccount();
    }
    @PostConstruct
    public void init(){
        System.out.println("初始化方法执行了");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("销毁方法执行了");
    }
}
public class Client {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac= new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as= (IAccountService) ac.getBean("accountServiceImpl");
        as.saveAccount();
        ac.close();
    }
}
/**
* 结果：初始化方法执行了
* 保存了账户
* 销毁方法执行了
**/

Spring中的新注解

  • @Configuration：指定当前类是一个配置类，作用和bean.xml是一样的。当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写，同理下面的扫包也不用写了。

    1
    ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfig.class);

  • @ComponentScan：用于通过注解指定Spring在创建容器时要扫描的包。value属性和basePackage的作用是一样的。都是用于指定创建容器时要扫描的包。使用此注解等同于在xml中配置了：

    1
    <context:component-scan base-package="com.ztygalaxy"></context:component-scan>

  • @Bean：用于把当前方法的返回值作为bean对象存入spring的IOC容器中。name属性用于指定bean的id，不写时默认值是当前方法的名称。当使用注解配置方法时，如果方法有参数，Spring框架会去容器中查找是否有可用的bean对象。查找方式和Autowired注解的作用是一样的，如果唯一类型匹配，多个按名称匹配。如示例中的dataSource。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//配置类
@Configuration
@ComponentScan(basePackages = {"com.ztygalaxy"})
public class SpringConfig {
    @Bean(name="runner")
    @Scope("prototype")//单例
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    @Bean(name="dataSource")
    public DataSource createDataSource(){
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        }catch(Exception e){
            throw new RuntimeException(e);
        }
    }
}

//使用
ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfig.class);
IAccountService as= (IAccountService) ac.getBean("accountService");

  • @Import：导入其他的配置类，使用import之后，有import注解的类就是主配置类（父配置类），而导入的都是子配置类。

    1
    @Import(JdbcConfig.class)

  • @PropertySource：用于指定properties文件的位置。属性value指定文件名称和文件路径，关键字classpath表示类路径下。

    1
    2
    @PropertySource("classpath:config/spring/jdbcConfig.properties")//有包就写包名
    @PropertySource("classpath:jdbcConfig.properties")
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
        @Bean(name="runner")
        @Scope("prototype")
        public QueryRunner createQueryRunner(DataSource dataSource){
            return new QueryRunner(dataSource);
        }
        @Bean(name="dataSource")
        public DataSource createDataSource(){
            try {
                ComboPooledDataSource ds = new ComboPooledDataSource();
                ds.setDriverClass(driver);
                ds.setJdbcUrl(url);
                ds.setUser(username);
                ds.setPassword(password);
                return ds;
            }catch(Exception e){
                throw new RuntimeException(e);
            }
        }
    }
    1
    2
    3
    4
    5
    #jdbc.properties
    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=root

Junit

Junit单元测试中，没有main方法也能执行。Junit集成了一个main方法，该方法会自动判断当前测试类中有哪些方法有@Test注解，Junit就让有@Test注解的方法执行。在执行测试方法时，Junit不知道是否使用了Spring框架，所以也就不会为我们读取配置文件或者配置类创建Spring核心容器。因此，当测试方法执行时，没有IOC容器，就算写了@Autowired也无法实现注入。

Spring整合Junit的配置

  1. 导入Spring整合Junit的Jar包（坐标）
1
2
3
4
5
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<version>5.0.2.RELEASE</version>
</dependency>
  1. 使用Junit提供的注解把原有的main方法替换成spring提供的
1
@RunWith(SpringJUnit4ClassRunner.class)
  1. 告知Spring的运行器，spring合IOC创建是基于xml还是注解的，并告诉位置。
1
2
3
4
//1. location：指定xml文件位置，加上classpath表示在类路径下
@ContextConfiguration(locations = "classpath:bean.xml")
//2. classes：指定注解类所在位置
@ContextConfiguration(classes = SpringConfig.class)

当使用Spring 5.x版本时，要求Junit的jar包是4.1.2及以上。

示例：

  • 版本1

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class AccountService {
        @Test
        public void testFindAll(){
            ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfig.class);
            IAccountService as= (IAccountService) ac.getBean("accountService");
            //上面两行在每个函数中都重复出现
            List<Account> accounts=as.findAllAccount();
            for (Account account:accounts)
                System.out.println(account);
        }
        //省略多个函数
    }

  • 版本2

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class AccountService {
        private ApplicationContext ac;
        private IAccountService as;
        @Before
        public void init(){//抽成init函数
            ac=new AnnotationConfigApplicationContext(SpringConfig.class);
            as= (IAccountService) ac.getBean("accountService");
        }
        @Test
        public void testFindAll(){
            List<Account> accounts=as.findAllAccount();
            for (Account account:accounts)
                System.out.println(account);
        }
        //省略多个函数
    }

  • 版本3

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     使用Spring装填
     @RunWith(SpringJUnit4ClassRunner.class)
     @ContextConfiguration(classes = SpringConfig.class)
     public class AccountService {
         @Autowired
         private IAccountService as;
         @Test
         public void testFindAll(){
             List<Account> accounts=as.findAllAccount();
             for (Account account:accounts)
                 System.out.println(account);
         }
        //省略多个函数
    }



标签
知识