Spring教程——黑马ssm系列心得笔记

Spring学习笔记

一、Spring简介

温馨提示：Spring的学习中会出现大量经典白学的案例，大师们为了偷懒而绞尽脑汁，我们要一步步的感受spring开发演化的过程。

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和

AOP（Aspect Oriented Programming：面向切面编程）为内核。（Spring是一个轻代码，重配置的框架）

提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术

，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

Spring的优势有：

1）方便解耦，简化开发

通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度耦合。

用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2）AOP 编程的支持

通过 Spring的 AOP 功能，方便进行面向切面编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松实现。

3）声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。

4）方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

5）方便集成各种优秀框架

Spring对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的支持。

6）降低 JavaEE API 的使用难度

Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

7）Java 源码是经典学习范例

Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java 设计模式灵活运用以及对 Java技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

Spring的体系结构：最下面的test表示都可以进行测试，Spring核心部分就是Test上面的核心容器，在核心容器的作用下就可以完成上面的应用。

二、Spring快速入门

本教程中会使用Web项目中的 service和Dao层的代码为例：

传统的没有使用框架的项目代码是这么写的：

我们需要使用哪个类，就直接使用new实例化一个对象出来。

而Spring框架为了实现解耦，将实例化对象这一任务交给了Spring容器：

Spring程序快速入门：

① 导入 Spring 开发的基本包坐标

② 编写 Dao 接口和实现类

③ 创建 Spring 核心配置文件

④ 在 Spring 配置文件中配置 UserDaoImpl

⑤ 使用 Spring 的 API 获得 Bean 实例

1.在maven项目中的pom.xml文件中导入Spring开发的基本坐标：

<properties> <spring.version>5.0.5.RELEASE</spring.version>
</properties> 

<dependencies>
<!--导入spring的context坐标，context依赖core、beans、expression-->
    <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
</dependency>
</dependencies>

2.编写Dao接口和实现类：

public interface UserDao {
public void save();
}


public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("UserDao save method running....");
	} 
}

3.创建Spring核心配置文件： applicationContext是Spring配置文件约定俗成的名字

//在类路径下（resources）创建applicationContext.xml配置文件

<?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">
</beans>

4.在Spring配置文件中配置UserDaoImpl

<?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="com.itheima.dao.impl.UserDaoImpl"></bean>		//这里就配置了UserDaoImpl类的实例化方式
</beans>

5.使用Spring的API获得Bean实例：

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

由此就实现了创建对象的权限转移到了Spring客户端而不是自己去new

Spring使用步骤：

① 导入坐标

② 创建Bean

③ 创建applicationContext.xml

④ 在配置文件中进行配置

⑤ 创建ApplicationContext对象getBean

三、Spring配置文件

1、Bean标签基本配置

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

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

基本属性：

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

Bean标签范围配置： scope属性：指对象的作用范围，取值如下（重点是前两个）：

取值范围	说明
singleton	单例的（默认值）
prototype	多例的
request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于session

1）当scope的取值为singleton时

写法：

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" scope="singleton">

Bean的实例化个数：1个 如果你硬要用spring创建两遍，那么这两个是一个

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

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了,注意：他比较特殊，创建容器时就已经创建好了对象

对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" scope="prototype">

Bean的实例化个数：多个

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

对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置（了解）

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

  <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" init-method="init">
      //在初始化对象时，就会调用该对象的 init方法作为初始化方法
  

• destroy-method：指定类中销毁方法名称

  <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl" destroy-method="destory">    //在销毁对象时，就会调用该对象的 destory方法作为初始化方法
  

2、Bean实例化三种方式

用来测试这三种方法的单元测试类：

package com.itheima.test;

import com.itheima.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

    @Test
    //测试scope属性
    public void test1(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        //app.close();
    }

}

1） 使用无参构造方法实例化（最常用）

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
//bean 标签中没有加任何东西就是无参构造的方式

2） 工厂静态方法实例化

工厂的静态方法返回Bean实例

// 用来创建UserDaoImpl的工厂类
package com.itheima.factory;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;

public class StaticFactory {

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

}

Spring配置文件：

<bean id="userDao" class="com.itheima.factory.StaticFactoryBean" 		factory-method="createUserDao" />

3） 工厂实例方法实例化

工厂的非静态方法返回Bean实例

// 用来创建UserDaoImpl的非静态工厂类
package com.itheima.factory;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;

public class DynamicFactory {

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

}

Spring配置文件

<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
 // 先有 工厂类的bean 然后再指出 产生userDao的工厂方法

3、Bean的依赖注入（重点）

Bean的依赖注入入门：

① 创建 UserService，UserService 内部在调用 UserDao的save() 方法:

public class UserServiceImpl implements UserService {

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

② 将 UserServiceImpl 的创建权交给 Spring

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>
// 无参构造

③ 从 Spring 容器中获得 UserService 进行操作

// 假设这是某servlet代码片段
ApplicationContext applicationContext = new 
	ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();

那么就有了问题：由于service类是需要使用Dao类的，即依赖Dao，我们是使用getBean把service 和 Dao对应的类都获取了一次，但是spring容器中两种对象我们都是有的，所以可以使用一种方式进行配置，在spring对象内部就让service类来获得Dao类，即依赖注入。

Bean的依赖注入分析：

目前UserService实例和UserDao实例都存在与Spring容器中，当前的做法是在容器外部获得UserService

实例和UserDao实例，然后在程序中进行结合。

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在

Spring容器中，将UserDao设置到UserService内部。

Bean的依赖注入概念：

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。

IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

Bean的依赖注入方式

怎么将UserDao怎样注入到UserService内部呢？

• 构造方法
• set方法

1）set方法注入

在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
	private UserDao userDao;
public void setUserDao(UserDao userDao) {
	this.userDao = userDao; 
}
    
@Override
public void save() {
	userDao.save();
	}
}

配置Spring容器调用set方法进行注入

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

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"> 
    <property name="userDao" ref="userDao"/>  ref属性：指定对象的引用   name:对象的属性名，要把对象名的首字母小写，比如UserDao对象的属性名就是userDao（重要）
</bean>

set方法注入也包括P命名空间注入（了解）

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：

//首先，需要在上面引入P命名空间：
xmlns:p="http://www.springframework.org/schema/p"

//然后修改注入方式
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDaoref="userDao"/>

2）构造方法注入

创建有参构造：

public class UserServiceImpl implements UserService {

@Override
public void save() {
	ApplicationContext applicationContext = new 
		ClassPathXmlApplicationContext("applicationContext.xml");

	UserDao userDao = (UserDao) applicationContext.getBean("userDao");
	userDao.save();
	}
}

配置Spring容器调用有参构造时进行注入：

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

Bean的依赖注入的数据类型:

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

注入数据的三种数据类型：

• 普通数据类型
• 引用数据类型
• 集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为

例，演示普通数据类型和集合数据类型的注入

1） 普通数据类型的注入

我感觉这样做就是得到bean的时候,初始化他的成员变量

// 这是我们要交给Spring创建的类
public class UserDaoImpl implements UserDao {
	private String company;
	private int age;
  public void setCompany(String company) {
	this.company = company;
}
  public void setAge(int age) {
	this.age = age;
}
  public void save() {
	System.out.println(company+"==="+age);
	System.out.println("UserDao save method running....");
	} 	
}

配置文件中的配置：

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
    <property name="company" value="传智播客"></property> 
    <property name="age" value="15"></property>
</bean>

这样通过依赖注入，创建对象时就把成员变量初始化了

2）集合数据类型（List）的注入

public class UserDaoImpl implements UserDao {
	private List<String> strList;
	public void setStrList(List<String> strList) {
		this.strList = strList;
}
	public void save() {
		System.out.println(strList);
		System.out.println("UserDao save method running....");
	} 
} 

配置string类型的注入

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">   // userdao的
    <property name="strList"> 						// 子标签 配userdao的strList
        <list>										// 给这个list配值
            <value>aaa</value> 
            <value>bbb</value> 
       	    <value>ccc</value>
        </list>

    </property>
</bean>

3)如果List集合里装的是一个对象 User：

public class UserDaoImpl implements UserDao {
	private List<User> userList;
	public void setUserList(List<User> userList) {
		this.userList = userList;
}
	public void save() {
	System.out.println(userList);
	System.out.println("UserDao save method running....");
	} 
}

配置文件：

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
    <property name="userList">
        <list>
        <bean class="com.itheima.domain.User"/>
		<bean class="com.itheima.domain.User"/>
		<ref bean="u1"/>
		<ref bean="u2"/>
		</list>
	</property>
</bean>

4）集合数据类型（ Map<String,User> ）的注入

public class UserDaoImpl implements UserDao {
	private Map<String,User> userMap;
	public void setUserMap(Map<String, User> userMap) {
	this.userMap = userMap;
}
	public void save() {
	System.out.println(userMap);
	System.out.println("UserDao save method running....");
	} 
}

配置文件： 普通数据类型用value，对象数据类型用ref

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
    <property name="userMap"> 
        <map>
        <entry key="user1" value-ref="u1"/>   因为是User对象的value，所以加ref
        <entry key="user2" value-ref="u2"/>
		</map>
	</property>
</bean>

集合数据类型（Properties）的注入

public class UserDaoImpl implements UserDao {
	private Properties properties;
public void setProperties(Properties properties) {
	this.properties = properties;
}
public void save() {
	System.out.println(properties);
	System.out.println("UserDao save method running....");
	 
}

配置文件：

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
    <property name="properties">
        <props> 
        <prop key="p1">aaa</prop> 
        <prop key="p2">bbb</prop>
        <prop key="p3">ccc</prop>
		</props>
	</property>
</bean>

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

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

<import resource="applicationContext-user.xml"/><import resource="applicationContext-product.xml"/>

4、Spring配置文件标签总结：

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

5、Spring相应API

ApplicationContext的继承体系：

**applicationContext：**接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象（图中蓝色为接口，浅绿色为抽象类，绿色为实现类）

ApplicationContext的实现类：

1）ClassPathXmlApplicationContext

它是从类的根路径下加载配置文件 推荐使用这种

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

2）FileSystemXmlApplicationContext

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

ApplicationContext app = new FileSystemXmlApplicationContext("C:\\Users\\apple\\IdeaProjects\\Spring\\itheima_spring_ioc\\src\\main\\resources\\applicationContext.xml");
//不太推荐 绝对路径的写法写死了    双斜杠是转义

3）AnnotationConfigApplicationContext

当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。注解方式后面要用。

getBean()方法使用：

public Object getBean(String name) throws BeansException {
	assertBeanFactoryActive();
	return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
    assertBeanFactoryActive();
	return getBeanFactory().getBean(requiredType);
}

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

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，

则此方法会报错。

ApplicationContext applicationContext = new 
	ClassPathXmlApplicationContext("applicationContext.xml");
	UserService userService1 = (UserService) applicationContext.getBean("userService");
//通过id的方式获取bean
	UserService userService2 = applicationContext.getBean(UserService.class);
//通过class方式获取bean,好处是已经知道bean的类型，不用再强转，坏处是配置文件中不能有多个同一类型的bean

四、Spring配置数据源（数据库连接池）

下面我们将一步步的从最开始来优化数据库连接池的使用过程：

数据源的开发步骤：

① 导入数据源的坐标和数据库驱动坐标

② 创建数据源对象

③ 设置数据源的基本连接数据

④ 使用数据源获取连接资源和归还连接资源

下面例子将同时创建C3P0和Druid数据库连接池

1.最最垃圾的使用数据库连接池：

Maven中导入c3p0和druid的坐标 导入mysql数据库驱动坐标

<!-- C3P0连接池 --> 
<dependency> 
    <groupId>c3p0</groupId> 
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
<!-- Druid连接池 -->
<dependency> 
    <groupId>com.alibaba</groupId> 
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId> 
    <version>5.1.39</version>
</dependency>

手动创建：创建C3P0连接池和druid连接池

 @Test
    //测试手动创建 druid 数据源
    public void test2() throws Exception {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

    @Test
    //测试手动创建 c3p0 数据源
    public void test1() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

2.抽取配置文件创建数据库连接池

相比于之前的方式，已经进行了优化，使用配置文件就有了解耦的效果，而不是把数据库连接给写死了

//jdbc.properties 文件内容
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root
 
    
 @Test
    //测试手动创建 c3p0 数据源(加载properties配置文件)
    public void test3() throws Exception {
        //读取配置文件
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");	// 直接获得 jdbc.properties
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");
        //创建数据源对象  设置连接参数
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);

        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();

    }     

3.Spring配置数据源（连接池）

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

1. DataSource有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的
2. DataSource要想使用需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入

Spring配置文件：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
</bean>

测试从容器当中获取数据源:

 @Test
    //测试Spring容器产生数据源对象
    public void test4() throws Exception {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = app.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

抽取jdbc配置文件：

实际开发中，为了配置清晰，jdbc配置文件不和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

// applicationContext.xml 下面的配置：
	<context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

Spring容器加载properties文件的方式

<context:property-placeholder location="xx.properties"/>
<property name="" value="${key}"/>

使用 $ 里面加key，就可以取到properties文件对应的value值

这是SpEL,Spring 表达式语言，有点类似于JSP里的EL表达式

五、Spring注解开发（重要）

1、Spring原始注解：

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

文件可以简化配置，提高开发效率。 重点：注解替代xml是一种趋势，能够提高效率。

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

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

Dao层实现类的写法：

package com.itheima.dao.impl;

import com.itheima.dao.UserDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
@Component("userDao")
//@Repository("userDao")
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("save running...");
    }
}

这里的@Component(“userDao”)注解就相当于告诉了spirng容器，我加了一个bean标签：

id为"userDao",因为在类里面写的，所以不用再写全限定名

service层实现类的写法:

ackage com.itheima.service.impl;

import com.itheima.dao.UserDao;
import com.itheima.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;



//<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
@Component("userService")


public class UserServiceImpl implements UserService {

   
// 下面两个注解是一起用的，在spring内部给service注入Dao实现类   
    @Autowired //按照数据类型从Spring容器中进行匹配的
    @Qualifier("userDao")  //是按照id值从容器中进行匹配的 但是主要此处@Qualifier结合@Autowired一起使用
   
    private UserDao userDao;

    public void save() {
        System.out.println(driver);
        userDao.save();
    }

}

这些都写完后，我们还得告诉spring容器去哪儿去扫描，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。：

<!--注解的组件扫描--> 
<context:component-scan base-package="com.itheima"></context:componentscan>
// 意思是扫描com包下的 itheima包下的所有类的注解

说明一下上面的注解

//@Autowired //按照数据类型从Spring容器中进行匹配的
    //@Qualifier("userDao")  //是按照id值从容器中进行匹配的 但是主要此处@Qualifier结合@Autowired一起使用
// 如果不加@Qualifier("userDao") 光用@Autowired也可以，但是想要使用多个相同class类型的就不行了
    @Resource(name="userDao") //@Resource相当于@Qualifier+@Autowired
    private UserDao userDao;

@Component标签的优化，要是都用这个标签虽然也行，但是太不清晰了，我们可以使用带有语义化的标签：

@Service("userService")    // 这是专门加在service层的标签，非必须，只是便于理解，一目了然
//@Repository 专门加在dao层   @Controller 专门加在web层（servlet）
public class UserServiceImpl implements UserService {

普通数据的注入：使用@value注解

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Value("com.mysql.jdbc.Driver")	// 看第一种方式，这么用也是写死了str，没有解耦的效果
    private String str;
    
    @Value("${jdbc.driver}")  // 这种用法才比较好，使用SpEL表达式，从配置文件中直接拿driver这个key对应的value，前提是配置文件jdbc.properites已经加载到了Spring 配置文件中
    //  applicationContext.xml中: <!--加载外部的properties文件 -->
  //  <context:property-placeholder location="classpath:jdbc.properties"/>
    private String driver;
    
    @Override
    public void save() {
        System.out.println(str);
        System.out.println(driver);
        System.out.println("save running... ...");
	} 
}

//jdbc.properties文件内容：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

使用@Scope标注Bean的范围：

//@Scope("prototype")		单例和多例只能写以一个
@Scope("singleton")
public class UserDaoImpl implements UserDao {
//此处省略代码
}

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法（了解）：

@PostConstruct
public void init(){
	System.out.println("初始化方法....");  // 在初始化以前执行
}

@PreDestroy
public void  destroy(){
	System.out.println("销毁方法.....");	// 在容器销毁前执行，但是要改成手动关闭容器才行
}

2、Spring新注解

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下（即原始注解完成不了的东西）：

 非自定义的Bean的配置：<bean>  (比如数据库连接池的bean，根本不是自己写的)
 加载properties文件的配置：<context:property-placeholder>    （如配置文件中加载jdbc.properties）
 组件扫描的配置：<context:component-scan>	
 引入其他文件：<import>

Spring新注解:

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package=“com.itheima”/>一样
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载.properties 文件中的配置
@Import	用于导入其他配置类

Spring新注解使用演示：

配置文件的变化，使用新注解就是为了实现用注解替代原始注解不能表示的内容，全面替代之前的核心配置文件applicationContext.xml，现在使用核心配置类来进行配置

这是核心配置类SpringCofiguration ：

package com.itheima.cofig;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;


@Configuration		//标志该类是Spring的核心配置类

@ComponentScan("com.itheima")   //代替组件扫描：<context:component-scan base-package="com.itheima"/>
//<import resource=""/>
@Import({DataSourceConfiguration.class})		//把子配置类引入主配置类 代替了引入其他文件：<import>
public class SpringCofiguration {

}

这是子配置类DataSourceConfiguration

package com.itheima.cofig;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;


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

    @Value("${jdbc.driver}")	// 用SpEl避免写死了而导致耦合
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean("dataSource")  //Spring会将当前方法的返回值以指定名称(dataSource)存储到Spring容器中,以后就可以用了，用来解决非自定义的Bean类型
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }

}

那么原始注解解决不了的四个问题都已经解决了，这次我们再创建对象就跟原来不一样了，因为不再使用xml作为核心配置文件，而是一个核心配置类：

这时候我们就要使用AnnotationConfigApplicationContext来创建Spring应用上下文对象了（即注解方式）

package com.itheima.web;

import com.itheima.cofig.SpringCofiguration;
import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {

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

}

六：Spring集成Junit

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

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

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

解决上述问题的思路：

• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它

• 将需要进行测试Bean直接在测试类中进行注入

Spring集成Junit步骤：

① 导入spring集成Junit的坐标

<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上--> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-test</artifactId> 
    <version>5.0.2.RELEASE</version>
</dependency> 
<dependency> 
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version> 
    <scope>test</scope>
</dependency>

② 使用@Runwith注解替换原来的运行期

@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {
}

③ 使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class)
//加载spring核心配置文件
//@ContextConfiguration(value = {"classpath:applicationContext.xml"})
//加载spring核心配置类
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
}

④ 使用@Autowired注入需要测试的对象

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

public class SpringJunitTest {
	@Autowired
	private UserService userService;
}

⑤ 创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
	@Autowired
	private UserService userService;
	@Test
	public void testUserService(){
		userService.save();
	} 
}

Spring集成Junit步骤

① 导入spring集成Junit的坐标

② 使用@Runwith注解替换原来的运行期

③ 使用@ContextConfiguration指定配置文件或配置类

④ 使用@Autowired注入需要测试的对象

⑤ 创建测试方法进行测试

七、Spring集成Web环境（servlet）

ApplicationContext应用上下文获取方式:

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从

容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置

文件加载多次(总不能获取多次吧)，应用上下文对象创建多次。

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加

载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域

中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

我们可以自己写一个监听器，然后通过servletContext域来传递ApplicationContext资源，就能保证唯一性了，

为了不把ApplicationContext app = new ClassPathXmlApplicationContext(applicationContext.xml); 的参数写死了（万一我们以后想叫abc.xml）呢，可以设置全局初始化参数：

<!--全局初始化参数  在web.xml中配置-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

//然后在监听器中再这样获取
String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
  ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);

在servlet中，在获得ApplicationContext的时候为了不把app这个字符串写死 ApplicationContext app = (ApplicationContext) servletContext.getAttribute(“app”);

我们可以抽取一个工具类：

package com.itheima.listener;

import org.springframework.context.ApplicationContext;

import javax.servlet.ServletContext;

public class WebApplicationContextUtils {

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

}

以后就能通过这个工具类获取了：

ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);

Spring提供获取应用上下文的工具：

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

具WebApplicationContextUtils供使用者获得应用上下文对象。上面提到的俩个东西Spring都帮我们写好了。

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

① 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）

② 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

导入Spring集成web的坐标

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

配置ContextLoaderListener监听器:

<!--全局参数--> 
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--Spring的监听器--> 
 <listener> 
        <listener-class>
org.springframework.web.context.ContextLoaderListener
		</listener-class>
</listener>

通过工具获得应用上下文对象:

ApplicationContext applicationContext = 
	WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

这个WebApplicationContextUtils是spring框架集成web帮我们写好的