Spring

1、Bean标签基本配置

用于配置对象交由Spring来创建

默认情况下它调用的是类中的无参构造函数，如果没有则不能创建成功

基本属性：

1. id：Bean实例在Spring容器中的唯一标识
2. class：Bean的全限定名称

2、Bean标签范围配置

scope指的是对象的作用范围

1）当scope的取值为singleton时：

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期：

• 对象创建：当应用加载，创建容器时，对象就被创建了
• 对象运行：只要容器在，对象一直活着
• 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时：

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean

Bean的生命周期：

• 对象创建：当使用对象时(getBean)，创建新的对象实例
• 对象运行：只要对象在使用中，就一直活着
• 对象销毁：当对象长时间不用时，就会被Java的垃圾回收站回收

3、Bean的生命周期配置

• init-method：指定类中的初始化方法名称
• destroy-method：指定类中销毁方法名称

执行顺序：创建对象->执行初始化方法->容器关闭/对象不用时执行销毁方法

4、Bean实例化三种方式

• 无参构造方法
• 工厂静态方法实例化
• 工厂实例方法实例化

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--  无参构造方法  -->
    <bean id="userDao" class="cn.ken.dao.impl.UserDaoImpl" scope="singleton" 
    init-method="init" destroy-method="destroy"></bean>

<!--  静态工厂方法  -->
    <bean id="userDao" class="cn.ken.factory.StaticFactory" factory-method="getuserDao"></bean>

<!--  实例工厂方法  -->
    <bean id="factory" class="cn.ken.factory.DynamicFactory"></bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>
</beans>

静态工厂——因为是静态方法，所以不需要创建静态工厂的对象就可以直接通过factory-method调用他的构造方法

public class StaticFactory {

    public static UserDao getuserDao(){
        return new UserDaoImpl();
    }
}

动态工厂——需要先实例化动态工厂的对象（即需要配置一个该工厂的bean），才能通过这个对象调用factory-method方法来创建userDao对象

public class DynamicFactory {

    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

因为有一些对象的创建不是通过无参构造函数创建，比如JDBC中Connection对象是用DriverManager.getConnection方法获取的，这时候就需要通过后面两种方法创建

5、Bean的依赖注入

实际开发中，我们需要在Spring容器中配置UserService和UserDao两个bean，当在界面层中获取UserService实例时，UserService实例内部需要Userdao实例，按照以往的做法，我们需要在Spring容器外部获取两次bean，如下：

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }
}

相当于是在Spring容器外将Dao组装到Service内部完成的操作

然而因为UserService和UserDao都在Spring容器中，而最终程序使用的是UserService，所以我们可以直接在Spring容器中把UserDao设置到UserService内部，如下：

<bean id="userDao" class="cn.ken.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="cn.ken.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>

property中name对应的是UserServiceImpl中的set方法的名字(即属性名)，ref表示通过哪个bean创建对象传给这个方法的参数

这样的话就只需要在界面层获取一次Service的Bean就行了，Service层中的getBean方法不再需要，因为其在容器内部已经装配了UserDao，如下：

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
//        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        UserDao userDao = (UserDao) app.getBean("userDao");
//        userDao.save();
        userDao.save();
    }
}

当然如果在业务层不是通过getBean获取的UserService而是通过new获取，则执行save方法会出现空指针异常，因为UserService中的UserDao属性并没有赋初值，只有通过bean获取的才会装配有UserDao对象

6、依赖注入的概念

依赖注入：它是Spring框架核心IOC的具体实现

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况，IOC解耦只是降低了他们的依赖关系，但不会消除。例如业务层仍然会调用持久层的方法

那这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了，简单地说就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

注入方式

1）set方法注入

上文所演示的方法即为set方法注入，该方法可以有简便的写法：P命名空间注入

P命名空间注入本质也是set方法注入，但是写法更为简便，首先引入p命名空间：xmln:p="http://www.springframework.org/schema/p"，

其次修改注入方式：<bean id="userService" class="cn.ken.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>

2）有参构造函数注入

<bean id="userDao" class="cn.ken.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="cn.ken.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

其中name表示的是有参构造函数的参数名，ref表示通过哪个bean创建对象传给这个参数

//需要现在UserServiceImpl中添加有参构造函数
private UserDao userDao;

public UserServiceImpl() {
}

public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}

7、Bean的依赖注入的数据类型

上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入

以下演示set方法注入（默认类中已经有了对应的setter方法）：

1）普通数据类型

<bean id="userService" class="cn.ken.service.impl.UserServiceImpl">
    <property name="name" value="cyh"></property>
    <property name="age" value="19"></property>
</bean>

此处注入的是普通数据类型，故property中使用的是value属性而不是ref属性，ref属性是用于注入对象的引用

2）集合

public class UserServiceImpl implements UserService {

    private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void save() {
        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);
    }
}

<bean id="userService" class="cn.ken.service.impl.UserServiceImpl">
        <property name="strList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="map1" value-ref="user1"></entry>
                <entry key="map2" value-ref="user2"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="prop1">ppp1</prop>
                <prop key="prop2">ppp2</prop>
                <prop key="prop3">ppp3</prop>
            </props>
        </property>
    </bean>
    <bean id="user1" class="cn.ken.domain.User">
        <property name="name" value="cyh"></property>
        <property name="addr" value="st"></property>
    </bean>
    <bean id="user2" class="cn.ken.domain.User">
        <property name="name" value="czk"></property>
        <property name="addr" value="gd"></property>
    </bean>

输出结果

[aaa, bbb, ccc]
{map1=User{name='cyh', addr='st'}, map2=User{name='czk', addr='gd'}}
{prop2=ppp2, prop1=ppp1, prop3=ppp3}

8、引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以可以将部分配置拆解到其他配置文件中，而在Spring主配置文件中通过import标签加载

<import resource="applicationContext-xxx.xml">

9、总结

<bean>标签
	id属性:在容器中Bean实例的唯一标识，不允许重复
	class属性:要实例化的Bean的全限定名
	scope属性:Bean的作用范围，常用是singleton(默认)和prototype
	<property>标签：属性引入
		name属性:属性名称
		value属性:注入的普通属性值
		ref属性:注入的对象引用值
		<list>标签
		<map>标签
		<propos>标签
	<constructor-arg>标签
		//内置属性与标签同property
<import>标签：导入其他的Spring的分文件

二、Spring相关的API

1、ApplicationContext的实现类

1. ClassPathXmlApplicationContext
   • 它是从类的根路径下加载配置文件（推荐使用）
2. FileSystemXmlApplicationContext
   • 它是从磁盘路径上加载配置文件，配置文件可以放在磁盘的任何位置
3. AnnotationConfigApplicationContext
   • 当使用注解配置容器对象时，需要使用此类来创建Spring容器，它用来读取注解

下图为配置文件部署后的位置，位于classes目录下，故第一种方法的参数只需要填写文件名

2、getBean()的使用方法

当参数的类型为字符串型时，表示根据Bean的id从容器中获得Bean实例，返回Object类型，需要强转

当参数得类型为Class类型时，表示根据类型从从其中匹配Bean实例，不需要强转，当容器中相同类型得Bean有多个时会报错

为了避免出现多个同类型Bean时报错，可以同时传入字符串类型和Class类型，则不需要强转，又能精确匹配Bean，如下：

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = app.getBean("userService",UserService.class);
userService.save();

三、Spring配置数据源(连接池)

1、数据源开发步骤

1. 导入数据源的坐标和数据库驱动坐标
2. 创建数据源对象
3. 设置数据源的基本连接数据
4. 使用数据源获取连接资源和归还连接资源

2、使用Spring配置数据源

可以将DataSource的创建交给Spring容器去完成

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/movie"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123456"></property>
</bean>

public class DataSourceTest {
    @Test
    public void testDruid() throws SQLException {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        DruidDataSource dataSource = app.getBean(DruidDataSource.class);
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

3、抽取JDBC配置文件

为了让配置文件各司其职，一般会把数据源的配置信息单独写在jdbc.propertie文件中，而不是直接写在Spring配置文件（虽然写在Spring也能完成解耦）

applicationContext.xml加载jdbc.properties配置文件获得连接信息

首先，需要引入context命名空间和约束路径

• 命名空间：xmlns:context=“http://www.springframework.org/schema/context”
• 约束路径：http://www.springframework.org/schema/context

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClassName}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${password}"></property>
    </bean>
</beans>

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/movie
jdbc.username=root
password=123456

tip：<property name="username" value="${jdbc.username}"></property>此处不能写为$username，否则会加载本机的用户名

四、Spring注解开发

1、Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率

Spring原始注解主要是替代的配置

注意

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类

<!--注解的组件扫描-->
<context:component-scan base-package="cn.ken"></context:component-scan>

2、实例

Controller层

public class UserController {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService bean = app.getBean(UserService.class);
        bean.save();
        app.close();
    }
}

使用ClassPathXmlApplicationContext而不是ApplicationContext类，以便调用close方法，才能看到销毁过程

Service层

//@Component("userService")
@Service("userService")//参数为该Bean的id
@Scope("singleton")
public class UserServiceImpl implements UserService {
    
    @Value("${driverClassName}")//在容器中寻找key为driverClassName的键值对
    private String driver;

    @Autowired
    //@Qualifier("userDao")
    private UserDao userDao;

    //public void setUserDao(UserDao userDao) {
    //    this.userDao = userDao;
    //}

    @Override
    public void save() {
        userDao.save();
    }
    
    @PostConstruct
    public void init(){
        System.out.println("初始化中：driver=" + driver);
    }
    
    @PreDestroy
    public void destroy(){
        System.out.println("销毁中");
    }
}

@Autowired注解会按照数据类型从Spring容器中自动进行匹配，如果UserDao只有一个实现的Bean，则@Qualifier注解可以省略

即@Autowired是按照类型自动匹配的，@Qualifier是按照id进行匹配的（当有多个实现的Bean时就需要加上这个注解来选择使用哪个Bean注入，且此注解不能单独使用，得配合@Autowired一起使用）

当需要通过id匹配时也可以直接使用@Resource注解，则直接写@Resource(name="userDao")就行（相当于@Autowired + @Qualifier(“userDao”)）

如果使用注解配置可以不用set方法，注解标志处会通过暴力反射直接为该field赋值，不需要set方法

Dao层

//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("saving...");
    }
}

输出结果

初始化中：driver=com.mysql.cj.jdbc.Driver
saving...
销毁中

3、Spring新注解

使用上面注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：

1. 非自定义的Bean的配置：<bean>
2. 加载properties文件的配置：<context:property-placeholder>
3. 组件扫描的配置：<context:component-scan>
4. 引入其他文件：<import>

4、使用新注解取代xml文件

public class Main {
    public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = app.getBean("userService", UserService.class);
        userService.test();
    }
}

//标志该类是Spring的核心配置类即applicationContext.xml
@Configuration
//注解的组件扫描
//<=><context:component-scan base-package="cn.ken"></context:component-scan>
@ComponentScan("cn.ken")
//引入其他配置文件
//<=>import resource="applicationContext-xxx.xml"
@Import({DataSourceConfiguration.class,XxxConfiguration.class})
public class SpringConfiguration {

}

//加载properties文件中的配置
//<=><context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {

    @Value("${driverClassName}")
    private String driver;
    @Value("${url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${password}")
    private String password;

    @Bean("dataSource")
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

五、Spring集成Junit

1、原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码

ApplicationContext app = new ClassPathXmlApplicationContext("bean.xml");
UserService userService = app.getBean("userService",userService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常，所以不能轻易删掉

2、上述问题的解决思路

1. 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
2. 将需要进行测试的Bean直接在测试类中注入

3、Spring集成Junit步骤

1. 导入Spring集成Junit的坐标
2. 使用@Runwith注解替换原来的运行期
3. 使用@ContextConfiguration指定配置文件或配置类
4. 使用Autowired注入需要测试的对象
5. 创建测试方法进行测试

导入Spring集成Junit的坐标

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.13</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.3.12</version>
</dependency>

@ContextConfiguration(classes = {SpringConfiguration.class})
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private DataSource dataSource;

    @Test
    public void test1() throws SQLException {
        userService.test();
        System.out.println(dataSource.getConnection());
    }
}

六、Spring集成web环境

1、ApplicationContext应用上下文获取方式

应用上下文对象是通过new ClasspathXmlApplicationContext(Spring配置文件)方式获取的，但是每次从容器中获得Bean时都要new一次，这样就会导致配置文件被加载多次，应用上下文对象创建多次。

2、自定义ContextLoaderListener

在web项目中，可以使用ServletContextListener监听web应用的启动，我们可以在web应用启动时，就加载Spring配置文件，创建应用上下文对象ApplicationContext，再将其存储到最大的域ServletContext域中，这样就可以在任意位置从域中获得应用上下文对象了。

@WebListener
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        ServletContext servletContext = sce.getServletContext();
        servletContext.setAttribute("app",app);
        System.out.println("监听ing");
    }
}

@WebServlet("/login")
public class Login extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        ApplicationContext app = (ApplicationContext) this.getServletContext().getAttribute("app");
        UserService userService = app.getBean(UserService.class);
        userService.test();
    }
}

优化写法（解耦）

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 将Spring配置类写在配置文件中解耦 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cn.ken.config.SpringConfiguration</param-value>
    </context-param>
    
</web-app>

@WebListener
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext servletContext = sce.getServletContext();
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
        try {
            Class aClass = Class.forName(contextConfigLocation);
            ApplicationContext app = new AnnotationConfigApplicationContext(aClass);
            servletContext.setAttribute("app",app);
            System.out.println("监听ing");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 将Spring容器的获取提取出来，则使用时不需要知道其保存在servletContext中的属性名
public class WebApplicationContextUtils {

    public static ApplicationContext getApplicationContext(ServletContext servletContext){
        return (ApplicationContext) servletContext.getAttribute("app");
    }
}

@WebServlet("/login")
public class Login extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        // 通过静态方法直接获取Spring容器应用上下文
        // ApplicationContext app = (ApplicationContext) this.getServletContext().getAttribute("app");
        ApplicationContext app = WebApplicationContextUtils.getApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.test();
    }
}

3、Spring提供获取应用上下文工具

上文中的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具webApplicationContextUtils供使用者获得应用上下文对象

所以我们需要做的只有两件事：

1. 导入Spring-web坐标
2. 在web.xml中配置ContextLoaderListener监听器
3. 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.3.12</version>
</dependency>

//@WebServlet("/login")
public class Login extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        ApplicationContext app = (ApplicationContext) WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService bean = (UserService) app.getBean(UserService.class);
        bean.test();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true"
>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>cn.ken.controller.Login</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

</web-app>