Spring Framewor 简介

Spring5.0已经全面支持JDK8，建议JDK使用1.8版本。

Spring Framework是Spring家族中其他框架的底层基础。

Spring Framewor 架构

Spring Framework的发展经历了很多版本的变更，每个版本都有相应的调整。

Spring Framework 架构：

核心层

Core Container：核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块。
AOP层
- AOP：面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强。
- Aspects：AOP是编程思想，Aspects是对AOP思想的具体实现。
数据层
- Data Access：数据访问，Spring全家桶中有对数据访问的具体实现技术。
- Data Integration：数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis。
- Transactions：事务，Spring中事务管理是Spring AOP的一个具体实现。
Web层
Test层

Spring主要整合了Junit来完成单元测试和集成测试。

从Spring Framework 5没有架构图，而最新的架构图是4版本，所以可以认为Spring Framework从4版本开始架构就已经趋于稳定，没有什么变动。

Spring 核心概念

在Spring核心概念主要包含：

IOC
- IOC，Inversion of Control，即控制反转。
- 控制反转：主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部的一种思想。
例如，业务（Service）层要使用到数据（DAO）层的类对象。此时就可以使用IOC思想，由外部程序给业务层创建数据层对象。这样可以降低业务层和数据层之间的耦合性。如果数据层的实现更改的话，就无需在业务层中修改实现类。
- IOC容器
  - Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"。
  - IOC容器负责对象的创建、初始化等一系列工作。
- Bean
  - 在IOC容器中，被创建或被管理的对象统称为Bean。
  - IOC容器中存放的就是一个个的Bean对象。
DI
- 依赖注入：在容器中建立Bean与Bean之间的依赖关系的整个过程。
例如，业务层和数据层在IOC容器中创建Bean后，并不能直接工作，因为业务层需要依赖数据层才能正确工作。所以此时就需要使用依赖注入，在业务层和数据层之间建立依赖关系。

IOC和DI的最终目标就是充分解耦。在Spring Framewor中的实现依靠：

使用IOC容器管理Bean（IOC）。
在IOC容器内将有依赖关系的Bean进行关系绑定（DI）。

最终，使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系。

配置文件方法使用IOC/DI

使用 IOC 容器创建 Bean（bean 标签）

基础配置：

创建Maven项目，项目基础结构如下：
- 📁project-file-name
  - 📁src
    - 📁main
      - 📁java
        
        📁com.linner
        
        📁dao
        
        📁domain
        
        📁service
      - 📁resourcs
    - 📁test
      - 📁java
        
        📁com.linner
        
        📁service
    - 📄pom.xml

添加Spring Framework的依赖jar包：

 1<dependencies>
 2    <!--...-->
 3    <!--springframework-->
 4    <dependency>
 5        <groupId>org.springframework</groupId>
 6        <artifactId>spring-context</artifactId>
 7        <version>5.2.10.RELEASE</version>
 8    </dependency>
 9    <!--junit-->
10    <dependency>
11        <groupId>junit</groupId>
12        <artifactId>junit</artifactId>
13        <version>4.12</version>
14        <scope>test</scope>
15    </dependency>
16    <!--...-->
17</dependencies>

添加业务层、数据层类：

User.java:

 1package com.linner.domain;
 2
 3public class User {
 4    Integer id;
 5    String username;
 6    String password;
 7
 8    public Integer getId() {
 9        return id;
10    }
11
12    public void setId(Integer id) {
13        this.id = id;
14    }
15
16    public String getUsername() {
17        return username;
18    }
19
20    public void setUsername(String username) {
21        this.username = username;
22    }
23
24    public String getPassword() {
25        return password;
26    }
27
28    public void setPassword(String password) {
29        this.password = password;
30    }
31
32    @Override
33    public String toString() {
34        return "User{" +
35                "id=" + id +
36                ", username='" + username + '\'' +
37                ", password='" + password + '\'' +
38                '}';
39    }
40}

DAO(仅测试，无需查询数据库):

接口：

 1package com.linner.dao;
 2
 3import com.linner.domain.User;
 4
 5import java.util.List;
 6
 7public interface UserDao {
 8
 9    List<User> findAll();
10
11    User findById(int id);
12
13    void delete(int id);
14
15    void save(User user);
16
17    void update(User user);
18}

实现类：

 1package com.linner.dao.impl;
 2
 3import com.linner.dao.UserDao;
 4import com.linner.domain.User;
 5
 6import java.util.List;
 7
 8public class UserDaoImpl implements UserDao {
 9    @Override
10    public List<User> findAll() {
11        System.out.println("UserDao findAll...");
12        return null;
13    }
14
15    @Override
16    public User findById(int id) {
17        System.out.println("UserDao findById:" + id);
18        return null;
19    }
20
21    @Override
22    public void delete(int id) {
23        System.out.println("UserDao delete:" + id);
24    }
25
26    @Override
27    public void save(User user) {
28        System.out.println("UserDao save:" + user);
29    }
30
31    @Override
32    public void update(User user) {
33        System.out.println("UserDao update:" + user);
34    }
35}

Service:

接口：

 1package com.linner.service;
 2
 3import com.linner.domain.User;
 4
 5import java.util.List;
 6
 7public interface UserService {
 8
 9    List<User> findAll();
10
11    User findById(int id);
12
13    void delete(int id);
14
15    void save(User user);
16
17    void update(User user);
18}

实现类：

 1package com.linner.service.impl;
 2
 3import com.linner.dao.UserDao;
 4import com.linner.dao.impl.UserDaoImpl;
 5import com.linner.domain.User;
 6import com.linner.service.UserService;
 7
 8import java.util.List;
 9
10public class UserServiceImpl implements UserService {
11    private UserDao userDao = new UserDaoImpl();
12
13    @Override
14    public List<User> findAll() {
15        System.out.println("UserService findAll...");
16        userDao.findAll();
17        return null;
18    }
19
20    @Override
21    public User findById(int id) {
22        System.out.println("UserService findById:" + id);
23        userDao.findById(id);
24        return null;
25    }
26
27    @Override
28    public void delete(int id) {
29        System.out.println("UserService delete:" + id);
30        userDao.delete(id);
31    }
32
33    @Override
34    public void save(User user) {
35        System.out.println("UserService save:" + user);
36        userDao.save(user);
37    }
38
39    @Override
40    public void update(User user) {
41        System.out.println("UserService update:" + user);
42        userDao.update(user);
43    }
44}

测试方法：

 1package com.linner.service;
 2
 3import com.linner.domain.User;
 4import com.linner.service.UserService;
 5import com.linner.service.impl.UserServiceImpl;
 6import org.junit.Test;
 7
 8import java.util.List;
 9
10public class UserServiceTest {
11    private UserService userService = new UserServiceImpl();
12
13    @Test
14    public void testFindAll() {
15        userService.findAll();
16        System.out.println("------------");
17    }
18
19    @Test
20    public void testFindById() {
21        int id = 12;
22        userService.findById(id);
23        System.out.println("------------");
24    }
25
26    @Test
27    public void testDelete() {
28        int id = 12;
29        userService.delete(id);
30        System.out.println("------------");
31    }
32
33    @Test
34    public void testSave() {
35        User user = new User();
36        user.setId(12);
37        user.setUsername("abc");
38        user.setPassword("abc123");
39        userService.save(user);
40        System.out.println("------------");
41    }
42
43    @Test
44    public void testUpdate() {
45        User user = new User();
46        user.setId(12);
47        user.setUsername("abc");
48        user.setPassword("abc123");
49        userService.update(user);
50        System.out.println("------------");
51    }
52}

创建Bean

在📁resourcs目录下创建String配置文件applicationContext.xml，并使用<bean>标签配置Bean：

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
5
6    <!--添加UserService-->
7    <bean id="userService" class="com.linner.service.impl.UserServiceImpl"/>
8</beans>

接着在程序中使用Spring提供的方法获取IOC容器。然后从IOC容器中获取对象并调用其方法，修改Test类进行测试：

 1public class UserServiceTest {
 2
 3    // private UserService userService = new UserServiceImpl();
 4
 5    // 使用IOC无需自己创建对象（对象由IOC容器分配
 6    private static UserService userService;
 7    // 这里使用静态代码块获取容器和Bean
 8    static {
 9        // 获取IOC容器
10        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
11        userService = (UserService) ctx.getBean("userService");
12    }
13
14    // ...
15}

IOC核心容器创建方式有：

ClassPathXmlApplicationContext：类路径下的XML配置文件。
```
1ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
```
ClassPathXmlApplicationContext的参数为XML配置文件在类路径下的相对路径。

FileSystemXmlApplicationContext：

1ApplicationContext ctx = new FileSystemXmlApplicationContext("/home/linner/IdeaProjects/my-springfw-demo/src/main/resources/applicationContext.xml");

FileSystemXmlApplicationContext的参数为XML配置文件在文件系统下的绝对路径。

UserServiceTest执行成功说明配置成功。

Bean 的基础配置

<bean>标签是作为Spring配置Bean使用。其基本形式为：

1<bean id="" class=""/>

id：Bean标签的唯一标识。在同一个上下文中(配置文件)不能重复。
class：Bean的类型。包含包名和类名。

别名（name 属性）

<bean>的name属性可以为<bean>指定别名，别名可以有多个，使用,，;，空格进行分隔。如：

1<bean id="userService" name="service userEbi" class="com.linner.service.impl.UserServiceImpl"/>

说明：EBI全称Enterprise Business Interface，译为企业业务接口。

获取 Bean 的方式（getBean() 方法）

使用getBean()获取Bean的方式有三种：

按照名称获取：

是指在getBean()方法中传递String类型的参数，参数的值为Bean的名称。
```
1Object getBean(String s)
```
按照类型获取：

需要保证该类型在IOC容器中有且仅有一个Bean（不能包含多个同类型的Bean）。在参数中传递该类型的class。
```
1<T> T getBean(Class<T> aClass)
```
按照名称和类型获取：

在参数中传入Bean的名称和类型。
```
1 <T> T getBean(String s, Class<T> aClass)
```

作用范围（scope 属性）

<bean>的scope属性可以为<bean>设置作用范围，可选值为：

singloton：默认，表示创建的对象为单例（在整个IOC容器中所有获取到的该对象都为同一个对象）。如：
```
1<bean id="userService" class="com.linner.service.impl.UserServiceImpl" scope="singloton"/>
```
或：
```
1<bean id="userService" class="com.linner.service.impl.UserServiceImpl" />
```
实际上，单例对象在容器被获取的时候就已经被创建了。

prototype：表示创建的对象为非单例（每次在IOC容器中获取到的对象都是不同的对象）。如：

1<bean id="userService" name="service userEbi" class="com.linner.service.impl.UserServiceImpl" scope="prototype"/>

Example：

将UserService设为单例：

String配置文件applicationContext.xml中userService的<bean>（由于Spring默认创建的是单例，所以这里可以选择不添加scope="singloton"）：

1<bean id="userService" class="com.linner.service.impl.UserServiceImpl">
2</bean>

创建新的测试类TestForUserServiceScope：

 1package com.linner.service;
 2
 3import com.linner.domain.User;
 4import org.junit.Test;
 5import org.springframework.context.ApplicationContext;
 6import org.springframework.context.support.ClassPathXmlApplicationContext;
 7
 8public class TestForUserServiceScope {
 9    private static ApplicationContext ctx;
10    static {
11        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
12    }
13
14    @Test
15    public void testFindAll() {
16        UserService userService = (UserService) ctx.getBean("userService");
17        System.out.println(userService);
18        userService.findAll();
19        System.out.println("------------");
20    }
21
22    @Test
23    public void testFindById() {
24        UserService userService = (UserService) ctx.getBean("userService");
25        System.out.println(userService);
26        int id = 12;
27        userService.findById(id);
28        System.out.println("------------");
29    }
30
31    @Test
32    public void testDelete() {
33        UserService userService = (UserService) ctx.getBean("userService");
34        System.out.println(userService);
35        int id = 12;
36        userService.delete(id);
37        System.out.println("------------");
38    }
39
40    @Test
41    public void testSave() {
42        UserService userService = (UserService) ctx.getBean("userService");
43        System.out.println(userService);
44        User user = new User();
45        user.setId(12);
46        user.setUsername("abc");
47        user.setPassword("abc123");
48        userService.save(user);
49        System.out.println("------------");
50    }
51
52    public void testUpdate() {
53        UserService userService = (UserService) ctx.getBean("userService");
54        System.out.println(userService);
55        User user = new User();
56        user.setId(12);
57        user.setUsername("abc");
58        user.setPassword("abc123");
59        userService.update(user);
60        System.out.println("------------");
61    }
62}

执行UserServiceTest1后，在输出中可以发现：每个测试方法中使用getBean()获取到的UserService都是同个对象。

将UserService设为非单例：

修改String配置文件applicationContext.xml：
```
1<bean id="userService" class="com.linner.service.impl.UserServiceImpl" scope="prototype">
```
再次执行UserServiceTest1，可以发现：每个测试方法中使用getBean()获取到的UserService都是不同的对象。

Bean 的实例化

实例化Bean分为三种方式：

构造方法
静态工厂
实例工厂

构造方法实例化 Bean（默认）

<bean>默认是使用无参的构造方法实例化Bean。并且，Spring底层用的是反射（因为即使将构造方法设置为private依然可以使用）。

静态工厂实例化 Bean（factory-method 属性）

静态工厂实例化Bean指的是通过工厂类来创建对象。

一般情况下是使用如下方法静态工厂实例化对象：

创建com.linner.factory包，并编写UserDaoFactory：

 1package com.linner.factory;
 2
 3import com.linner.dao.UserDao;
 4import com.linner.dao.impl.UserDaoImpl;
 5
 6public class UserDaoFactory {
 7    public static UserDao getUserDao() {
 8        return new UserDaoImpl();
 9    }
10}

编写TestFroInstanceUserDao测试类：

 1package com.linner.dao;
 2
 3import com.linner.domain.User;
 4import com.linner.factory.UserDaoFactory;
 5import org.junit.Test;
 6
 7public class TestFroInstanceUserDao {
 8    private UserDao userDao = UserDaoFactory.getUserDao();
 9
10    @Test
11    public void testFindAll() {
12        userDao.findAll();
13        System.out.println("------------");
14    }
15
16    @Test
17    public void testFindById() {
18        int id = 12;
19        userDao.findById(id);
20        System.out.println("------------");
21    }
22
23    @Test
24    public void testDelete() {
25        int id = 12;
26        userDao.delete(id);
27        System.out.println("------------");
28    }
29
30    @Test
31    public void testSave() {
32        User user = new User();
33        user.setId(12);
34        user.setUsername("abc");
35        user.setPassword("abc123");
36        userDao.save(user);
37        System.out.println("------------");
38    }
39
40    @Test
41    public void testUpdate() {
42        User user = new User();
43        user.setId(12);
44        user.setUsername("abc");
45        user.setPassword("abc123");
46        userDao.update(user);
47        System.out.println("------------");
48    }
49}

在IOC容器中使用静态工厂实例化：

在Spring配置文件中加入UserDao的配置：
```
1<bean id="userDao" class="com.linner.factory.UserDaoFactory" factory-method="getUserDao"/>
```
- class：工厂类的类全名。这里指定的是创建UserDao的静态工厂类UserDaoFactory。
- factory-method：class指定的工厂类中创建对象的方法名。这里指定的是工厂类中用来创建UserDao的方法。

修改TestFroInstanceUserDao：

 1import org.springframework.context.ApplicationContext;
 2import org.springframework.context.support.ClassPathXmlApplicationContext;
 3
 4public class TestFroInstanceUserDao {
 5    private static UserDao userDao;
 6    static {
 7        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 8        userDao = (UserDao) ctx.getBean("userDao");
 9    }
10    // ...
11}

注意：使用这种方法实例化，不能将该Bean注入到其他Bean中。

实例工厂实例化 Bean

使用 Bean 的 factory-bean 属性

实例化工厂实例化Bean是指，为工厂类添加一个单例的Bean（为区分则称为工厂Bean），然后在要实例化的Bean中指定使用这个工厂Bean作为实例化工厂。

修改UserDaoFactory（不使用静态工厂）：

1public class UserDaoFactory {
2    public UserDao getUserDao() {
3        return new UserDaoImpl();
4    }
5}

在Spring的配置文件中添加UserDaoFactory的<bean>，并且修改UserDao的<bean>：

1<bean id="userDaoFactory" class="com.linner.factory.UserDaoFactory"/>
2<bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>

添加了一个userDaoFactory工厂Bean。
factory-bean：工厂的实例对象，即工厂Bean的id或name。
factory-method：工厂对象中具体创建对象的方法名，即factory-bean指定对象中创建该对象的方法名。

成功执行TestFroInstanceUserDao即配置成功。

使用 FactoryBean 接口

创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法：

 1package com.linner.factory;
 2
 3import com.linner.dao.UserDao;
 4import com.linner.dao.impl.UserDaoImpl;
 5import org.springframework.beans.factory.FactoryBean;
 6
 7public class UserDaoFactoryBean implements FactoryBean {
 8
 9    @Override
10    public Object getObject() throws Exception {
11        return new UserDaoImpl();
12    }
13
14    @Override
15    public Class<?> getObjectType() {
16        return UserDao.class;
17    }
18
19    @Override
20    public boolean isSingleton() {
21        return true;
22    }
23}

getObject()：创建实例化对象并返回。代替原始实例工厂中创建对象的方法。
getObjectType()：返回所创建类的Class对象。
isSingleton()：设置对象是否为单例。默认true，可以不重写。

修改Spring配置文件：

1<bean id="userDao" class="com.linner.factory.UserDaoFactoryBean"/>

成功执行TestFroInstanceUserDao即配置成功。

Bean 的生命周期

Bean的生命周期是指Bean对象从创建到销毁的整个过程。对Bean的生命周期进行控制，可以在Bean创建后（如加载初始化需要用到资源）还有销毁前（如释放资源）执行一些操作。

init-method 和 destroy-method 属性

Spring控制生命周期的第一个方法便是使用Spring配置文件中<bean>的 init-method 和 destroy-method 属性。

在UserDaoImpl中创建初始化方法和销毁方法（方法名任意）：

 1public class UserDaoImpl implements UserDao {
 2
 3    /**
 4     * 初始化方法
 5     */
 6    public void init() {
 7        System.out.println("UserDao init...");
 8    }
 9
10    /**
11     * 销毁方法
12     */
13    public void destroy() {
14        System.out.println("UserDao destroy...");
15    }
16
17    // ...
18}

修改Spring配置文件：

1<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"/>

init-method：class指定的类中的初始化方法，在创建Bean对象后执行。
destroy-method：class指定的类中的销毁方法，在销毁Bean前执行。

编写TestForLifeCycle测试类：

 1package com.linner;
 2
 3import com.linner.dao.UserDao;
 4import org.junit.Test;
 5import org.springframework.context.support.ClassPathXmlApplicationContext;
 6
 7public class TestForLifeCycle {
 8    @Test
 9    public void testForLifeCycle() {
10        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
11        UserDao userDao = (UserDao) ctx.getBean("userDao");
12        userDao.findAll();
13        ctx.close();
14    }
15}

对比之前的ctx对象，这里ctx对象使用的类型从ApplicationContext变成了ClassPathXmlApplicationContext。这是因为ApplicationContext中并没有close()方法。而想要执行Bean对象中的destroy()，就必须在程序退出前关闭IOC容器（调用ctx.close()）。

注册钩子关闭容器

在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器。

修改TestForLifeCycle：

1public class TestForLifeCycle {
2    @Test
3    public void testForLifeCycle() {
4        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
5        ctx.registerShutdownHook();
6        UserDao userDao = (UserDao) ctx.getBean("userDao");
7        userDao.findAll();
8    }
9}

注意：ApplicationContext中也没有registerShutdownHook()。所以这里使用的是ClassPathXmlApplicationC对象。

InitializingBean 和 DisposableBean 接口

Spring 提供了InitializingBean和DisposableBean接口以更加方便地控制Bean生命周期。使用这两个接口则无需通过Sping配置文件中的init-method和destroy-method 属性来控制生命周期。

实现InitializingBean接口的afterPropertiesSet()方法和DisposableBean接口的destroy()方法：

 1import org.springframework.beans.factory.DisposableBean;
 2import org.springframework.beans.factory.InitializingBean;
 3
 4public class UserDaoImpl implements UserDao, InitializingBean, DisposableBean {
 5
 6    /**
 7     * InitializingBean接口的初始化方法
 8     */
 9    @Override
10    public void afterPropertiesSet() throws Exception {
11        System.out.println("UserDao init by afterPropertiesSet()...");
12    }
13
14    /**
15     * DisposableBean接口的销毁方法
16     */
17    @Override
18    public void destroy() {
19        System.out.println("UserDao destroyed by destroy()...");
20    }
21
22    // ...
23}

在Spring配置文件中删除init-method和destroy-method属性：

1<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl"/>

使用 Bean 标签的注意事项

class属性不能使用接口。因为接口不能创建对象。
获取Bean无论是通过id还是name获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException。
Bean默认为单例，避免了对象的频繁创建与销毁，达到了对Bean对象的复用，性能高。
如果对象是有状态对象（即该对象有成员变量可以用来存储数据）。因为所有请求线程共用一个Bean对象，所以会存在线程安全问题。
如果对象是无状态对象（即该对象没有成员变量没有进行数据存储）。因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
适合交给容器进行管理的Bean对象：
- 表现层对象
- 业务层对象
- 数据层对象
- 工具对象
不适合交给容器进行管理的Bean对象：

封装实例的域对象。会引发线程安全问题。

DI 依赖注入

上面的程序，在UserServiceImpl中依然需要手动创建对象：

1public class UserServiceImpl implements UserService {
2    private UserDao userDao = new UserDaoImpl();
3    // ...
4}

当前业务层和数据层的耦合性还是很高。此时就需要使用依赖注入来降低耦合性。

Spring依赖注入支持简单数据类型、引用数据类型还有集合注入，并且提供了两种注入方式：

Setter注入
构造器注入

基础配置：

创建Maven项目。
添加Spring Framework和Junit的依赖jar包。
添加业务层、数据层类：
- User.java: 同使用IOC容器创建Bean中的User.java。
- DAO(仅测试，无需查询数据库): 同使用IOC容器创建Bean中的DAO（UserDao）。
- Service: 同使用IOC容器创建Bean中的Service（UserService）。

测试方法：

 1package com.linner.service;
 2
 3import com.linner.domain.User;
 4import com.linner.service.UserService;
 5import com.linner.service.impl.UserServiceImpl;
 6import org.junit.Test;
 7
 8import java.util.List;
 9
10public class UserServiceTest {
11    private static UserService userService;
12    static {
13        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
14        userService = (UserService) ctx.getBean("userService");
15    }
16
17    @Test
18    public void testFindAll() {
19        userService.findAll();
20        System.out.println("------------");
21    }
22
23    @Test
24    public void testFindById() {
25        int id = 12;
26        userService.findById(id);
27        System.out.println("------------");
28    }
29
30    @Test
31    public void testDelete() {
32        int id = 12;
33        userService.delete(id);
34        System.out.println("------------");
35    }
36
37    @Test
38    public void testSave() {
39        User user = new User();
40        user.setId(12);
41        user.setUsername("abc");
42        user.setPassword("abc123");
43        userService.save(user);
44        System.out.println("------------");
45    }
46
47    @Test
48    public void testUpdate() {
49        User user = new User();
50        user.setId(12);
51        user.setUsername("abc");
52        user.setPassword("abc123");
53        userService.update(user);
54        System.out.println("------------");
55    }
56}

Setter 注入（property 标签）

Setter注入是指，在实现类中为需要注入的属性设置Setter方法，让Spring能够使用Setter方法自动给属性创建对象。

注入引用数据类型

要在Bean中注入引用类型属性，注入的属性其实现类必须得是IOC容器中的Bean。

在UserServiceImpl中，取消手动创建对象，并为userDao属性提供setter方法：

1public class UserServiceImpl implements UserService {
2    private UserDao userDao;
3
4    public void setUserDao(UserDao userDao) {
5        this.userDao = userDao;
6    }
7    // ...
8}

修改Spring配置文件applicationContext.xml：

1<!--...-->
2<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl"/>
3<bean id="userService" class="com.linner.service.impl.UserServiceImpl">
4    <property name="userDao" ref="userDao"/>
5</bean>
6<!--...-->

为UserService注入UserDao要在UserService的<bean>标签中使用<property>标签。·

<property>表示配置当前<bean>的属性，其标签属性有：

name：<bean>所指的实现类的属性名，表示配置哪一个具体的属性。
ref：要配置的属性的Bean的id或name，表示参照哪一个<bean>（该注入的Bean必须在容器中存在）。

成功运行ServiceBeanTest说明注入成功。

如果要注入多个属性，则在实例类中加入多个属性，为其设置Setter并在Bean中配置多个<property>即可。

注入简单数据类型

在Bean中注入简单类型属性，简单数据类型并不用在配置文件中为简单类型添加Bean标签配置。

为BookDao添加简单类型属性：

 1import org.springframework.beans.factory.InitializingBean;
 2
 3public class UserDaoImpl implements UserDao, InitializingBean {
 4
 5    private String databaseName;
 6    private int connectionNum;
 7
 8    public void setConnectionNum(int connectionNum) {
 9        this.connectionNum = connectionNum;
10    }
11
12    public void setDatabaseName(String databaseName) {
13        this.databaseName = databaseName;
14    }
15
16    @Override
17    public void afterPropertiesSet() throws Exception {
18        System.out.println("UserDao init: DatabaseName=" + this.databaseName
19                        + ", ConnectionNum=" + this.connectionNum);
20    }
21    // ...
22}

在Spring配置文件中为UserDao添加<property>标签：

1<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl">
2    <property name="databaseName" value="mysql"/>
3    <property name="connectionNum" value="10"/>
4</bean>

name：含义不变，与引用注入类型用法中的含义相同。
value: 要配置的属性的值，必须是简单数据类型。对于参数类型，Spring在注入的时候会自动转换，但是有可能会发生转换错误的情况。

成功运行ServiceBeanTest说明注入成功。

集合注入

修改UserDao，为其添加集合类型参数和对应Setter方法：

 1import java.util.*;
 2
 3public class UserDaoImpl implements UserDao, InitializingBean {
 4
 5    private int[] array;
 6    private List<String> list;
 7    private Set<String> set;
 8    private Map<String,String> map;
 9    private Properties properties;
10
11    // ...此处省略setter方法
12
13    @Override
14    public void afterPropertiesSet() throws Exception {
15        System.out.println("UserDao init: " +
16                        "array=" + Arrays.toString(array) +
17                        ", list=" + list +
18                        ", set=" + set +
19                        ", map=" + map +
20                        ", properties=" + properties);
21    }
22    // ...
23}

修改Spring配置文件：

 1<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl">
 2    <property name="array">
 3        <array>
 4            <value>1</value>
 5            <value>2</value>
 6            <value>3</value>
 7        </array>
 8    </property>
 9    <property name="list">
10        <list>
11            <value>a</value>
12            <value>b</value>
13            <value>c</value>
14        </list>
15    </property>
16    <property name="set">
17        <set>
18            <value>a</value>
19            <value>a</value>
20            <value>b</value>
21            <value>c</value>
22        </set>
23    </property>
24    <property name="map">
25        <map>
26            <entry key="a" value="1"/>
27            <entry key="b" value="2"/>
28            <entry key="c" value="3"/>
29        </map>
30    </property>
31    <property name="properties">
32        <props>
33            <prop key="a">1</prop>
34            <prop key="b">2</prop>
35            <prop key="c">3</prop>
36        </props>
37    </property>
38</bean>

<property>：Setter注入依然使用该标签。其name属性含义不变。

集合类型的值在其标签下定义。

<array>：定义数组类型的值。

数组元素中的值使用<value>标签定义。
<value>标签中的值要与数组的类型一致。一般形式如下：

1<property name="...">
2    <array>
3        <value>...</value>
4        <value>...</value>
5        <value>...</value>
6        <!--...-->
7    </array>
8</property>

<list>：定义List类型的值。

其用法与<array>类似。

1<property name="...">
2    <list>
3        <value>...</value>
4        <value>...</value>
5        <value>...</value>
6        <!--...-->
7    </list>
8</property>

<set>：定义Set类型的值。其用法与<array>类似。

1<property name="...">
2    <set>
3        <value>...</value>
4        <value>...</value>
5        <value>...</value>
6        <!--...-->
7    </set>
8</property>

<map>：定义Map类型的值。

其元素使用<entry>标签定义。并且元素的key使用key属性定义，元素的value使用value属性定义。
key和value属性的值要和Map的类型对应。

1<property name="...">
2    <map>
3        <entry key="..." value="..."/>
4        <entry key="..." value="..."/>
5        <entry key="..." value="..."/>
6        <!--...-->
7    </map>
8</property>

<props>：定义Properties的值。

其元素使用<prop>标签定义。key使用key属性定义，value在标签中定义。

1<property name="...">
2    <props>
3        <prop key="...">...</prop>
4        <prop key="...">...</prop>
5        <prop key="...">...</prop>
6        <!--...-->
7    </props>
8</property>

注意：

List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用。

集合中要添加引用类型，只需要把<value>标签改成<ref>标签。

构造器注入（constructor-arg 标签）

构造器注入是指Spring通过Bean的实例类中，带参的构造方法将其他Bean进行注入。

注入引用数据类型

在UserServices中删除Setter方法（此处删除Setter方法是为了证明使用的是构造器注入而非Setter注入）并添加带参的构造方法：

1public class UserServiceImpl implements UserService {
2
3    private UserDao userDao;
4
5    public UserServiceImpl(UserDao userDao) {
6        this.userDao = userDao;
7    }
8    // ...
9}

修改Spring配置文件：

1<bean id="userService" class="com.linner.service.impl.UserServiceImpl">
2    <constructor-arg name="userDao" ref="userDao"/>
3</bean>

<constructor-arg>中name和ref属性的含义与<property>的含义类似。只不过name属性指的是Bean实例类型中构造方法的参数名（名称必须要一致）。

成功运行ServiceBeanTest说明注入成功。

如果要注入多个类型数据，则在构造方法中加入多个参数并在Bean中配置多个<constructor-arg>即可。

注入简单数据类型

在UserDao中删除Setter方法，并为其添加带参的构造方法：

 1public class UserDaoImpl implements UserDao, InitializingBean {
 2
 3    private String databaseName;
 4    private int connectionNum;
 5
 6    public UserDaoImpl(String databaseName, int connectionNum) {
 7        this.databaseName = databaseName;
 8        this.connectionNum = connectionNum;
 9    }
10    // ...
11}

修改Spring配置文件：

1<bean id="userDao" class="com.linner.dao.impl.UserDaoImpl">
2    <constructor-arg name="databaseName" value="mysql"/>
3    <constructor-arg name="connectionNum" value="10"/>
4</bean>

成功运行ServiceBeanTest说明注入成功。

集合注入

构造器注入集合数据类型的方式与Setter注入集合数据类型的方式类似。

只不构造器注入要定义相应的带参方法，并且将<property>标签改为<constructor-arg>。

自动装配（bean 标签的 autowire 属性）

自动装配只适用于引用类型依赖注入，不能对简单类型进行操作。

自动装配的方式有：

按类型（常用）
按名称
按构造方法（的参数）

按类型自动装配

为UserService中的属性（如userDao）提供Setter方法。接着在Spring中为UserService删除其<bean>标签下的所有<proerty>或<constructor-arg>。然后给<bean>添加autowire="byType"：

1<bean id="userService" class="com.linner.service.impl.UserServiceImpl" autowire="byType"/>

注意：

类中对应属性的Setter方法不能省略。

被注入的对象必须要被Spring的IOC容器管理。

按照类型自动装配如果Spring在IOC中找到多个类型相同的Bean则会报NoUniqueBeanDefinitionException错误。

按名称自动装配

一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入。

修改Spring配置文件（添加autowire="byName"）：

1<bean id="userService" class="com.linner.service.impl.UserServiceImpl" autowire="byName"/>

注意：

按名称自动装配是根据Setter方法的名称在IOC容器中寻找名称对应的Bean（Bean的id或name）。如setUserDao()则需要寻找名称为userDao的Bean。

如果按照名称找不到对应的Bean，则注入null（不会报错！）。

按名称自动装配中，实例类成员变量名与配置耦合，不推荐使用。

配置文件管理第三方 Bean（properties 文件加载）

数据源对象管理（DAO层）

以Druid为例：

pom.xml依赖：

 1<dependencies>
 2    <!--Spring Framework-->
 3    <dependency>
 4        <groupId>org.springframework</groupId>
 5        <artifactId>spring-context</artifactId>
 6        <version>5.2.10.RELEASE</version>
 7    </dependency>
 8    <!--MySQL JDBC-->
 9    <dependency>
10        <groupId>mysql</groupId>
11        <artifactId>mysql-connector-java</artifactId>
12        <version>8.0.29</version>
13    </dependency>
14    <!--Druid-->
15    <dependency>
16        <groupId>com.alibaba</groupId>
17        <artifactId>druid</artifactId>
18        <version>1.2.11</version>
19    </dependency>
20</dependencies>

JDBC配置（jdbc.properties）：

1jdbc.driver=com.mysql.jdbc.Driver
2jdbc.url=jdbc:mysql://localhost:33061/spring_db
3jdbc.username=root
4jdbc.password=n546,Lin0

Spring配置（applicationContext.xml）：

 1<?xml version="1.0" encoding="UTF-8"?>
 2<!--需要开启context命名空间-->
 3<beans xmlns="http://www.springframework.org/schema/beans"
 4    xmlns:context="http://www.springframework.org/schema/context"
 5    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6    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">
 7
 8    <!--加载jdbc配置文件-->
 9    <context:property-placeholder location="classpath*:jdbc.properties"/>
10
11    <!--Druid Bean-->
12    <bean class="com.alibaba.druid.pool.DruidDataSource">
13        <property name="driverClassName" value="${jdbc.driver}"/>
14        <property name="url" value="${jdbc.url}"/>
15        <property name="username" value="${jdbc.username}"/>
16        <property name="password" value="${jdbc.password}"/>
17    </bean>
18
19</beans>

编写App.java：

 1package com.linner;
 2
 3import com.alibaba.druid.pool.DruidDataSource;
 4import org.springframework.context.ApplicationContext;
 5import org.springframework.context.support.ClassPathXmlApplicationContext;
 6
 7public class App {
 8    public static void main(String[] args) {
 9        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
10        DruidDataSource dataSource = ctx.getBean(DruidDataSource.class);
11        System.out.println(dataSource);
12    }
13}

如果终端成功输出dataSource，说明配置成功。

注解开发

Spring对注解支持的版本历程:

2.0版开始支持注解
2.5版注解功能趋于完善
3.0版支持纯注解开发

基础配置：

创建Maven项目。
添加Spring Framework和Junit的依赖jar包。
添加业务层、数据层类：
- User.java: 同使用IOC容器创建Bean中的User.java。
- DAO(仅测试，无需查询数据库): 同Setter 注入中的DAO（UserDao）。
- Service: 同Setter 注入中的Service（UserService）。

Spring 配置文件包扫描

为了能够获取到使用注解定义的Bean，需要在Spring配置文件中使用包扫描来识别出指定包下的所有Bean。

创建Spring配置文件。在Spring配置文件中加入包扫描：

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3       xmlns:context="http://www.springframework.org/schema/context"
4       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5       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">
6
7    <context:component-scan base-package="com.linner"/>
8</beans>

注意：

使用<context:component-scan>包扫描，需要在<beans>标签中加入属性：
1xmlns:context="http://www.springframework.org/schema/context"
接着在<context:component-scan>的xsi:schemaLocation属性中加入值：
1http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

<context:component-scan>：

component：组件，Spring将管理的Bean视作自己的一个组件。
scan：扫描。
base-package：该属性指定Spring框架扫描的包路径，它会扫描指定包及其子包中的所有类上的注解。
- 包路径越精确，如：com.linner.dao.impl，扫描的范围越小速度越快。
- 包路径越广泛，如：com.linner，扫描的范围越大速度越慢。
一般扫描到项目的组织名称即Maven的<groupId>下（如：com.linner）即可。包扫描不仅能扫描当前包，还能扫描当前包下的子包。

创建 Bean 对象（@Component）

在UserDao中添加@Component注解：

1import org.springframework.stereotype.Component;
2
3@Component("userDao")
4public class UserDaoImpl implements UserDao {
5    // ...
6}

编写新的测试类UserDaoTest：

 1package com.linner.dao;
 2
 3import com.linner.domain.User;
 4import org.junit.Test;
 5import org.springframework.context.ApplicationContext;
 6import org.springframework.context.support.ClassPathXmlApplicationContext;
 7
 8public class UserDaoTest {
 9    private static UserDao userDao;
10    static {
11        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
12        userDao = (UserDao) ctx.getBean("userDao");
13    }
14
15    @Test
16    public void testFindAll() {
17        userDao.findAll();
18        System.out.println("------------");
19    }
20
21    @Test
22    public void testFindById() {
23        int id = 12;
24        userDao.findById(id);
25        System.out.println("------------");
26    }
27
28    @Test
29    public void testDelete() {
30        int id = 12;
31        userDao.delete(id);
32        System.out.println("------------");
33    }
34
35    @Test
36    public void testSave() {
37        User user = new User();
38        user.setId(12);
39        user.setUsername("abc");
40        user.setPassword("abc123");
41        userDao.save(user);
42        System.out.println("------------");
43    }
44
45    @Test
46    public void testUpdate() {
47        User user = new User();
48        user.setId(12);
49        user.setUsername("abc");
50        user.setPassword("abc123");
51        userDao.update(user);
52        System.out.println("------------");
53    }
54}

@Component可以传递一个String类型的值。用于制定Bean的名称。

@Component可以直接使用而不指定名称。即，使用按类型获取Bean。但必须保证该类型在IOC中有且仅有一个Bean。如：

1@Component("userDao")
2public class UserDaoImpl implements UserDao {
3    // ...
4}

1UserDao userDao = ctx.getBean(UserDao.class);

@Component注解如果不起名称，会有一个默认值，就是将当前类名首字母转为小写后的值。所以也可以按照名称获取。

@Component还有其他三个衍生注解。

@Controller：表现层
@Service：业务层
@Repository：数据层

它们的作用和@Component是一样的，仅作为对表现层、业务层和数据层的类进行区分。如：

1import org.springframework.stereotype.Repository;
2
3@Repository("userDao")
4public class UserDaoImpl implements UserDao {
5    // ...
6}

1import org.springframework.stereotype.Repository;
2
3@Repository
4public class UserDaoImpl implements UserDao {
5    // ...
6}

纯注解开发（配置类、包扫描）

Spring3.0开启了纯注解开发模式，使用Java类替代配置文件。

删除Spring配置文件并创建配置类：

1package com.linner.config;
2
3import org.springframework.context.annotation.ComponentScan;
4import org.springframework.context.annotation.Configuration;
5
6@Configuration
7@ComponentScan("com.linner")
8public class SpringConfig {
9}

@Configuration：设定该类为Spring配置类。
@ComponentScan：包扫描，用来替换配置文件中的<context:component-scan>。在一个配置类中仅能使用一次。多个扫描路径使用数据格式，如：
```
1@ComponentScan({"com.linner.dao", "com.linner.service"})
```
包扫描不仅能扫描当前包，还能扫描当前包下的子包

修改UserDaoTest：

 1import com.linner.config.SpringConfig;
 2import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 3
 4public class UserDaoTest {
 5    private static UserDao userDao;
 6    static {
 7        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
 8        userDao = (UserDao) ctx.getBean("userDao");
 9    }
10    // ...
11}

使用Spring配置类，获取IOC容器应该使用AnnotationConfigApplicationContext对象：

1public AnnotationConfigApplicationContext(Class<?>... componentClasses)

作用范围（@Scope）

注解开发控制Bean的作用范围使用@Scope。它的值有两个：

"singleton"：默认值，将当前类设置为单例。

"prototype"：将当前类设置为多例。如：

1import org.springframework.context.annotation.Scope;
2
3@Repository
4@Scope("prototype")
5public class UserDaoImpl implements UserDao {
6    // ...
7}

生命周期控制（@PostConstruct 和 @PreDestroy）

注解控制Bean生命周期使用：

@PostConstruct：初始化。
@PreDestroy：销毁。

给UserDao加入初始化和销毁方法（方法名任意）：

 1import javax.annotation.PostConstruct;
 2import javax.annotation.PreDestroy;
 3
 4@Repository
 5public class UserDaoImpl implements UserDao {
 6
 7    /**
 8     * 初始化方法
 9     */
10    @PostConstruct
11    public void init() {
12        System.out.println(this + "init...");
13    }
14
15    /**
16     * 销毁方法
17     */
18    @PreDestroy
19    public void destroy() {
20        System.out.println(this + "destroy...");
21    }
22    // ...
23}

与使用注解开发的情况一样，要想执行destroy()需要在程序执行的时候关闭容器：
1ctx.close();
或：
1ctx.registerShutdownHook();
注意:@PostConstruct和@PreDestroy注解如果找不到，需要导入下面的jar包。
1<dependency>
2<groupId>javax.annotation</groupId>
3<artifactId>javax.annotation-api</artifactId>
4<version>1.3.2</version>
5</dependency>
原因是，从JDK9以后jdk中的javax.annotation包被移除了，这两个注解刚好就在这个包中。

依赖注入

给UserService配置Bean：

1import org.springframework.stereotype.Service;
2
3@Service
4public class UserServiceImpl implements UserService {
5    // ...
6}

按照类型注入

注解开发按照类型注入使用@Autowired注解。

给UserService注入UserDao：

 1import org.springframework.beans.factory.annotation.Autowired;
 2
 3@Service
 4public class UserServiceImpl implements UserService {
 5
 6    @Autowired
 7    private UserDao userDao;
 8    
 9    // ...
10}

@Autowired可以在实例类的成员变量上使用，也可以在Setter方法上使用，如：
 1@Service
 2public class UserServiceImpl implements UserService {
 3
 4    private UserDao userDao;
 5
 6    @Autowired
 7    public void setUserDao(UserDao userDao) {
 8        this.userDao = userDao;
 9    }
10    // ...
11}
在实例类的成员变量上使用@Autowired，即使将Setter方法注释掉依然可以注入成功。因为自动装配基于反射设计创建对象并通过暴力反射为属性进行设值（即使是私有属性也能设值）。

使用@Autowired需要保证该类型在IOC容器中有且仅有一个同类型的Bean。如果IOC容器中有对个同类型的Bean。那么@Autowired就会按照变量名和Bean的名称进行匹配。如：
1@Repository("userDao")
2public class UserDaoImpl implements UserDao { /*...*/ }
1@Service
2public class UserServiceImpl implements UserService {
3    @Autowired
4    private UserDao userDao;
5    // ...
6}
也能注入成功。

如果有多个同类型Bean，并且@Autowired名称匹配不上，那么会报NoUniqueBeanDefinitionException错误。

使用使用IOC容器创建Bean中的UserServiceTest，成功执行说明配置成功。

按照名称注入

注解开发名称注入使用@Qualifier注解来完成。

 1import org.springframework.beans.factory.annotation.Qualifier;
 2
 3@Service
 4public class UserServiceImpl implements UserService {
 5
 6    @Autowired
 7    @Qualifier("userDao")
 8    private UserDao userDao;
 9    
10    // ...
11}

在@Qualifier中指定Bean的名称。并且，@Qualifier必须和@Autowired一起使用才能起到按照名称注入的效果。

经过测试单独使用@Qualifier（不加@Autowired）的效果和按照类型注入的效果一样（可能会有其他细微的区别）。

注入简单数据类型

注解开发注入简单类型数据使用@Value注解。

 1import org.springframework.beans.factory.annotation.Value;
 2
 3@Repository
 4public class UserDaoImpl implements UserDao {
 5
 6    @Value("mysql")
 7    private String databaseName;
 8    @Value("10")
 9    private int connectionNum;
10
11    // ...
12}

@Value中的值使用String类型。如果要注入的是其他类型数据，需要按照其类型数据的格式编写。

注解读取 properties 配置文件

使用@Value的意义之一在于：读取properties配置文件的信息。

在resource目录下新建jdbc.properties：

1databaseName=mysql
2connectionNum=10

在配置类上添加@PropertySource注解：

1import org.springframework.context.annotation.PropertySource;
2
3@Configuration
4@ComponentScan("com.linner")
5@PropertySource("jdbc.properties")
6public class SpringConfig {
7}

修改UserDao：

 1@Repository
 2public class UserDaoImpl implements UserDao {
 3
 4    @Value("${databaseName}")
 5    private String databaseName;
 6    @Value("${connectionNum}")
 7    private int connectionNum;
 8    
 9    // ...
10}

读取多个配置文件，使用数组形式给@PropertySource传递字符串数组。如：
```
1@PropertySource({"jdbc.properties", "xxx.properties"})
```
@PropertySource注解属性中不支持使用通配符*，运行会报错。
@PropertySource注解属性中可以加入classpath:，代表从当前项目的根路径找文件：
```
1@PropertySource({"classpath:jdbc.properties"})
```

注解管理第三方 Bean

基础配置：

User.java: 同使用IOC容器创建Bean中的User.java。

UserDao：

 1package com.linner.dao;
 2
 3import com.linner.domain.User;
 4import org.apache.ibatis.annotations.*;
 5
 6import java.util.List;
 7
 8public interface UserDao {
 9
10    @Select("SELECT * FROM user_tb")
11    List<User> findAll();
12
13    @Select(("SELECT * FROM user_tb WHERE id = #{id}"))
14    User findById(int id);
15
16    @Delete("DELETE FROM user_tb WHERE id = #{id}")
17    void delete(int id);
18
19    @Insert("INSERT INTO user_tb(username, password) VALUES (#{username}, #{password})")
20    void save(User user);
21
22    @Update("UPDATE user_tb SET username = #{username}, password = #{password} WHERE id = #{id}")
23    void update(User user);
24}

UserService：

UserService接口同使用IOC容器创建Bean中的UserService.java。

UserService实现类UserServiceImpl.java：

 1package com.linner.service.impl;
 2
 3import com.linner.dao.UserDao;
 4import com.linner.domain.User;
 5import com.linner.service.UserService;
 6import org.springframework.beans.factory.annotation.Autowired;
 7import org.springframework.stereotype.Service;
 8
 9import java.util.List;
10
11@Service
12public class UserServiceImpl implements UserService {
13
14    @Autowired
15    private UserDao userDao;
16
17    @Override
18    public List<User> findAll() {
19        return userDao.findAll();
20    }
21
22    @Override
23    public User findById(int id) {
24        return userDao.findById(id);
25    }
26
27    @Override
28    public void delete(int id) {
29        userDao.delete(id);
30    }
31
32    @Override
33    public void save(User user) {
34        userDao.save(user);
35    }
36
37    @Override
38    public void update(User user) {
39        userDao.update(user);
40    }
41}

整合 Mybatis

pom.xml依赖：

 1<!--Spring Framework-->
 2<dependency>
 3    <groupId>org.springframework</groupId>
 4    <artifactId>spring-context</artifactId>
 5    <version>5.2.10.RELEASE</version>
 6</dependency>
 7<!--MySQL JDBC-->
 8<dependency>
 9    <groupId>mysql</groupId>
10    <artifactId>mysql-connector-java</artifactId>
11    <version>8.0.29</version>
12</dependency>
13<!--Druid-->
14<dependency>
15    <groupId>com.alibaba</groupId>
16    <artifactId>druid</artifactId>
17    <version>1.2.11</version>
18</dependency>
19<!--MyBatis-->
20<dependency>
21    <groupId>org.mybatis</groupId>
22    <artifactId>mybatis</artifactId>
23    <version>3.5.10</version>
24</dependency>
25<!--Spring JDBC-->
26<dependency>
27    <groupId>org.springframework</groupId>
28    <artifactId>spring-jdbc</artifactId>
29    <version>5.2.10.RELEASE</version>
30</dependency>
31<!--MyBatis Spring 整合包-->
32<dependency>
33    <groupId>org.mybatis</groupId>
34    <artifactId>mybatis-spring</artifactId>
35    <version>1.3.0</version>
36</dependency>
37<!--Junit 单元测试-->
38<dependency>
39    <groupId>junit</groupId>
40    <artifactId>junit</artifactId>
41    <version>4.13</version>
42    <scope>test</scope>
43</dependency>

建立User表：

1DROP TABLE IF EXISTS `user_tb`;
2CREATE TABLE `user_tb`  (
3`id` int(10) PRIMARY KEY AUTO_INCREMENT COMMENT '用户id',
4`username` varchar(10) NOT NULL COMMENT '用户名',
5`password` varchar(10) NOT NULL COMMENT '密码'
6) CHARACTER SET = utf8;

JDBC配置文件jdbc.properties：

1jdbc.driver=com.mysql.cj.jdbc.Driver
2jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false&useServerPrepStmts=true
3jdbc.username=root
4jdbc.password=root

JDBC配置类JdbcConfig.java：

 1package com.linner.config;
 2
 3import com.alibaba.druid.pool.DruidDataSource;
 4import org.springframework.beans.factory.annotation.Value;
 5import org.springframework.context.annotation.Bean;
 6
 7import javax.sql.DataSource;
 8
 9public class JdbcConfig {
10    // 驱动信息：
11    @Value("${jdbc.driver}")
12    private String driver;
13    @Value("${jdbc.url}")
14    private String url;
15    @Value("${jdbc.username}")
16    private String username;
17    @Value("${jdbc.password}")
18    private String password;
19
20    /**
21     * 获取DataSource对象
22     */
23    @Bean
24    public DataSource dataSource() {
25        DruidDataSource ds = new DruidDataSource();
26        // 设置驱动信息
27        ds.setDriverClassName(this.driver);
28        ds.setUrl(this.url);
29        ds.setUsername(this.username);
30        ds.setPassword(this.password);
31        return ds;
32    }
33}

@Bean：用于方法上，根据返回值类型自动产生Bean，并且方法的参数会按照类型自动装配。

Mybatis配置类MybatisConfig.java：

 1package com.linner.config;
 2
 3import org.mybatis.spring.SqlSessionFactoryBean;
 4import org.mybatis.spring.mapper.MapperScannerConfigurer;
 5import org.springframework.context.annotation.Bean;
 6
 7import javax.sql.DataSource;
 8
 9public class MybatisConfig {
10
11    @Bean
12    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
13        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
14        // 设置模型类的别名扫描
15        ssfb.setTypeAliasesPackage("com.linner.domain");
16        // 设置数据源
17        ssfb.setDataSource(dataSource);
18        return ssfb;
19    }
20
21    /**
22    * 获取MapperScannerConfigurer对象
23    */
24    @Bean
25    public MapperScannerConfigurer mapperScannerConfigurer() {
26        MapperScannerConfigurer msc = new MapperScannerConfigurer();
27        msc.setBasePackage("com.linner.dao");
28        return msc;
29    }
30}

SqlSessionFactoryBean：用于封装SqlSessionFactory需要的环境信息（原先的信息是在Mybatis配置文件中定义，如今可以在Java中用代码定义）。用于产生SqlSessionFactory对象。
- setTypeAliasesPackage()：设置模型类的别名扫描
- setDataSource()：设置DataSource。这里设置的DataSource通过方法的参数和@Bean注解实现了自动装配。并且自动装配的对像是Druid的DataSource。
MapperScannerConfigurer：用于加载Dao接口，创建代理对象保存到IOC容器中。此处设置的是dao包下的所有接口。这些接口都会被Mybatis创建成对象并且作为Bean保存在IOC容器中。即，使用ctx.getBean(UserDao.class)能获取到UserDao。

Spring配置类SpringConfig.java：

 1package com.linner.config;
 2
 3import org.springframework.context.annotation.*;
 4
 5@Configuration
 6@ComponentScan("com.linner")
 7@PropertySource("classpath:jdbc.properties")
 8@Import({JdbcConfig.class, MybatisConfig.class})
 9public class SpringConfig {
10}

@Import：用于引入其他配置类。如果要引入多个配置类则需要使用数组形式。

测试类UserServiceTest：

 1package com.linner;
 2
 3import com.linner.config.SpringConfig;
 4import com.linner.domain.User;
 5import com.linner.service.UserService;
 6import org.junit.Test;
 7import org.springframework.context.ApplicationContext;
 8import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 9
10import java.util.List;
11
12public class UserServiceTest {
13    private static UserService userService;
14    static {
15        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
16        userService = ctx.getBean(UserService.class);
17    }
18
19    @Test
20    public void testFindAll() {
21        List<User> users = userService.findAll();
22        for (User user : users) {
23            System.out.println(user);
24        }
25    }
26
27    @Test
28    public void testFindById() {
29        int id = 10;
30        User user = userService.findById(id);
31        System.out.println(user);
32    }
33
34    @Test
35    public void testDelete() {
36        int id = 10;
37        userService.delete(id);
38    }
39
40    @Test
41    public void testSave() {
42        User user = new User();
43        user.setUsername("张三");
44        user.setPassword("abc");
45        userService.save(user);
46    }
47
48    @Test
49    public void testUpdate() {
50        User user = new User();
51        user.setId(21);
52        user.setUsername("张三");
53        user.setPassword("abc");
54        userService.update(user);
55    }
56}

整合 Junit

引入Spring与测试有关的整合包：

1<!--Spring 测试整合包-->
2<dependency>
3    <groupId>org.springframework</groupId>
4    <artifactId>spring-test</artifactId>
5    <version>5.2.10.RELEASE</version>
6</dependency>

修改测试类UserServiceTest：

 1import org.junit.runner.RunWith;
 2import org.springframework.test.context.ContextConfiguration;
 3import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 4
 5import java.util.List;
 6
 7// 设置类运行器
 8@RunWith(SpringJUnit4ClassRunner.class)
 9// 设置Spring环境对应的配置
10// 加载配置类
11@ContextConfiguration(classes = {SpringConfig.class})
12// 加载配置文件
13//@ContextConfiguration(locations={"classpath:applicationContext.xml"})
14public class UserServiceTest {
15
16    // 自动装配UserService，删除static静态代码块
17    @Autowired
18    private UserService userService;
19
20
21}

AOP

AOP 介绍

一般常用的编程思想是OOP（面向对象编程，Object Oriented Programming）。

而AOP（面向切面编程，Aspect Oriented Programming），是一种编程范式，指导开发者如何组织程序结构。

编程思想主要的内容就是指导程序员该如何编写程序，所以AOP和OOP是两种不同的编程范式。

AOP的作用是在不改变原始设计的基础上为其进行功能增强。类似于Filter代理模式。

AOP术语：

连接点（JoinPoint）：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等。

在SpringAOP中，理解为方法的执行。

例如要对项目中UserDao的功能在不进行任何修改的前提下实现增强。那么UserDao中要增强的方法即为连接点。
切入点（Pointcut）：匹配连接点的式子。

在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法。

连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
通知（Advice）：在切入点处执行的操作，也就是共性功能。

在SpringAOP中，功能最终以方法的形式呈现。
通知类：定义通知的类。
切面（Aspect）：描述通知与切入点的对应关系。

通知是要增强的内容，会有多个；切入点是需要被增强的方法，也会有多个。通知和切入点的关系通过切面来描述。
目标对象（Target）：也叫原始对象。原始功能去掉共性功能对应的类产生的对象。即，配置AOP之前原设计的对象（要增强的对象）。
代理（Proxy）：通过通知类把目标对象增强后产生的对象。

目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现。

注解开发 AOP

基础配置：使用整合 Junit中的配置。

pom.xml导入坐标：
```
1<dependency>
2    <groupId>org.aspectj</groupId>
3    <artifactId>aspectjweaver</artifactId>
4    <version>1.9.4</version>
5</dependency>
```
- spring-context中已经包含了spring-aop，所以不需要再单独导入spring-aop。
- AspectJ是AOP思想的一个具体实现，AspectJ比起Spring的AOP实现来说，更加好用。

创建通知类UserDaoAdvice：

 1package com.linner.aop;
 2
 3import org.aspectj.lang.annotation.*;
 4import org.springframework.stereotype.Component;
 5
 6@Component
 7@Aspect
 8public class UserDaoAdvice {
 9
10    @Pointcut("execution(* com.linner.dao.UserDao.*(..))")
11    private void pt() {}
12
13    @Before("pt()")
14    public void method() {
15        System.out.println("Before...");
16    }
17
18}

@Aspect：设置当前类为AOP切面类。
@Pointcut：设置切入点方法。切入点定义需要一个不具有实际意义的方法（无参、无返回值、空方法体）。即UserDaoAdvice中的pt()。

@Pointcut中的execution()用来定义切入点。
@Before：设置切面。即设置当前通知方法在原始切入点方法前运行。

切入点定义作为@Before的参数。

在SpringConfig加入@EnableAspectJAutoProxy注解：

1import org.springframework.context.annotation.*;
2
3@Configuration
4@ComponentScan("com.linner")
5@EnableAspectJAutoProxy
6@PropertySource("classpath:jdbc.properties")
7@Import({JdbcConfig.class, MybatisConfig.class})
8public class SpringConfig {
9}

AOP 切入点表达式

切入点表达式是对要进行增强的方法的描述方式。切入点表达式的一般形式如下：

1动作关键字(访问修饰符 返回值类型 包名.类名.方法名(参数类型列表) 异常名)

由于通常都是对public方法进行定义，而public是默认的，所以可以省略。
切入点表达式定义的类可以是接口，也可以是其实现类。
AOP是在Spring中运行的，很显然切入点表达式定义的类必须存在IOC容器中。
如果匹配无参方法，直接省略参数。

Example：

1execution(void com.linner.dao.UserDao.delete(int))

切入点表达式通配符

*：匹配任意单个独立的任意符号。

可以独立出现，匹配任意返回值类型、单个包名（不能用做匹配完整包名）、类名、方法名或单个参数类型（即匹配单个单词）；也可以作为前缀或者后缀的匹配符出现。

如：
```
1execution（* com.linner.*.UserService.find*(*))
```
匹配com.linner包下的任意包中的UserService类或接口中，所有以find开头的、带有一个参数的、任意返回值类型的方法。
..：匹配多个连续的任意符号。

可以独立出现，常用于简化包名与参数的书写。
```
1execution（* com..UserService.findById(..))
```
匹配com包下的任意包中的UserService类或接口中所有名称为findById的（参数的数量、类型任意，返回值任意）方法。

+：专用于匹配子类类型。
```
1execution(* *..*Service+.*(..))
```
这个使用率较低。*Service+，表示所有以Service结尾的接口的子类。

书写技巧（所有代码按照标准规范开发，否则以下技巧全部失效）：

描述切入点通常描述接口，而不描述实现类，如果描述到实现类，就出现耦合了。
访问控制修饰符针对接口开发均采用public描述（简化书写）。
返回值类型对于增删改方法使用精准类型加速匹配，对于查询类使用*通配快速描述。
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配。
接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名。
方法名书写以动词进行精准匹配，名词采用*匹配，例如getById书写成getBy*，selectAll书写成selectAll。
参数规则较为复杂，根据业务方法灵活调整。
通常不使用异常作为匹配规则。

通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。

AspactJ提供了5种通知类型：

前置通知
后置通知
环绕通知
返回后通知
抛出异常后通知

1// 代码1
2try {
3    // 代码2
4    // 原始的业务操作
5    // 代码3
6} catch (Exception e) {
7    // 代码4
8}
9// 代码5

其中：

前置通知：代码1和代码2
返回后通知：代码3
抛出异常后通知：代码4
后置通知:代码5
环绕通知：上述整个代码块

通知方法的方法名称没有限制，只需在方法的上端使用注解定义即可。各通知类型的注解如下：

前置通知：@Before
后置通知：@After
环绕通知：@Around
返回后通知：@AfterReturning
抛出异常后通知：@AfterThrowing

这些注解的使用方式都是一样的。在对应的方法上定义，并且传入切入点（函数形式）。如：@Around("pt()")。

前置通知和后置通知的使用

前置通知和后置通知的使用方式一样：

 1@Component
 2@Aspect
 3public class UserDaoAdvice {
 4    @Pointcut("execution(* com.linner.dao.UserDao.*(..))")
 5    private void pt() {}
 6
 7    @Before("pt()")
 8    public void before() {
 9        System.out.println("Before...");
10    }
11
12    @After("pt()")
13    public void after() {
14        System.out.println("After...");
15    }
16}

环绕通知的使用

 1import org.aspectj.lang.ProceedingJoinPoint;
 2
 3@Component
 4@Aspect
 5public class UserDaoAdvice {
 6    @Pointcut("execution(* com.linner.dao.UserDao.findById(int))")
 7    private void pt() {}
 8
 9    @Around("pt()")
10    public Object around(ProceedingJoinPoint pjp) throws Throwable {
11        System.out.println("Before...");
12        Object ret = pjp.proceed();
13        System.out.println("After....");
14        return ret;
15    }
16}

环绕通知必须传入一个ProceedingJoinPoint参数。使用pjp.proceed()才可以在环绕通知中掉用原始方法。并且proceed()可以获取到原始方法的返回值。

如果也想让代理后的方法返回跟原始方法一样的值。那么必须定义环绕方法的返回值类型，并且使用proceed()获取原始方法的返回值并返回。

环绕通知比较灵活，可以将其定义成其他类型的通知，并且可以做到其他通知做不到的事情。例如循环调用原始方法等。

环绕通知需要抛出异常是因为。原始方法有可能会出现异常，并且原始方法的异常并不确定。所以为了提高通用性，环绕通知默认抛出异常。

如果环绕方法定义的是void类型，并且原始方法有返回值。如果此时在环绕通知中没有返回值，那么在掉用代理后的方法后，返回的是null。

返回后通知的使用

 1@Component
 2@Aspect
 3public class UserDaoAdvice {
 4    @Pointcut("execution(* com.linner.dao.UserDao.findById(int))")
 5    private void pt() {}
 6
 7    @AfterReturning("pt()")
 8    public void afterReturning() {
 9        System.out.println("After Returning...");
10    }
11}

注意：返回后通知是需要在原始方法正常执行后才会被执行，如果原始方法执行的过程中出现了异常，那么返回后通知不会被执行。

后置通知是不管原始方法有没有抛出异常都会被执行。

异常后通知

 1@Component
 2@Aspect
 3public class UserDaoAdvice {
 4    @Pointcut("execution(* com.linner.service.UserService.findAll())")
 5    private void pt() {}
 6
 7    @AfterThrowing("pt()")
 8    public void afterThrowing() {
 9        System.out.println("After Throwing...");
10    }
11}

在UserServiceImpl.findAll()中模拟错误即可触发。例如使用int a = 1/0;模拟错误。

注意：异常后通知是需要原始方法抛出异常。如果没有抛异常，异常后通知将不会被执行。

Spring Framework

目录

Spring Framewor 简介

Spring Framewor 架构

Spring 核心概念

配置文件方法使用IOC/DI

使用 IOC 容器创建 Bean（bean 标签）

Bean 的基础配置

别名（name 属性）

获取 Bean 的方式（getBean() 方法）

作用范围（scope 属性）

Bean 的实例化

构造方法实例化 Bean（默认）

静态工厂实例化 Bean（factory-method 属性）

实例工厂实例化 Bean

使用 Bean 的 factory-bean 属性

使用 FactoryBean 接口

Bean 的生命周期

init-method 和 destroy-method 属性

注册钩子关闭容器

InitializingBean 和 DisposableBean 接口

使用 Bean 标签的注意事项

DI 依赖注入

Setter 注入（property 标签）

注入引用数据类型

注入简单数据类型

集合注入

构造器注入（constructor-arg 标签）

注入引用数据类型

注入简单数据类型

集合注入

自动装配（bean 标签的 autowire 属性）

按类型自动装配

按名称自动装配

配置文件管理第三方 Bean（properties 文件加载）

数据源对象管理（DAO层）

注解开发

Spring 配置文件包扫描

创建 Bean 对象（@Component）

纯注解开发（配置类、包扫描）

作用范围（@Scope）

生命周期控制（@PostConstruct 和 @PreDestroy）

依赖注入

按照类型注入

按照名称注入

注入简单数据类型

注解读取 properties 配置文件

注解管理第三方 Bean

整合 Mybatis

整合 Junit

AOP

AOP 介绍

注解开发 AOP

AOP 切入点表达式

切入点表达式通配符

通知类型

前置通知和后置通知的使用

环绕通知的使用

返回后通知的使用

异常后通知

版权

相关文章

评论