Spring学习流程

Spring简介

---

1. 什么是Spring？

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

2. Spring的优势在哪？

1. 方便解耦，简化开发 => Spring离不开解耦
2. AOP 编程的支持
3. 声明式事务的支持
4. 方便程序的测试 => 可以集成junit

---

Spring的快速入门

---

1. Spring的开发步骤

1. 导入 Spring 开发的基本包坐标 => 普通项目的导包
2. 编写 Dao 接口和实现类
3. 创建 Spring 核心配置文件 => applicationContext.xml
4. 在 Spring 配置文件中配置 UserDaoImpl
5. 使用 Spring 的 API 获得 Bean 实例 => getBean方法

2. 代码实现

1. 导入Spring开发的基本包坐标

<properties>
	<spring.version>5.0.5.RELEASE</spring.version>
</properties>
<!--导入spring的context坐标，context依赖core、beans、expression-->
<dependencies> 
    <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 核心配置文件:
   在resources路径下创建applicationContext.xml配置文件
   配置文件可以任意命名，但习惯命名为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">
    <!-- 就这句话，将userDao注入到容器中 -->
   <bean id="userDao" class="com.jerry.dao.impl.UserDaoImpl"></bean>
</beans>

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

public static void main(String[] args) {
   
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.save();
}

---

Spring的文件配置

---

1. Bean标签的基本配置

1. Bean标签用于将配置对象交给Spring来创建，而不是我们自己new一个对象
2. 默认调用无参构造方法，如果没有就会创建失败
3. id属性：唯一标识符，每个Bean实例在Spring容器中的id不相同
4. class属性：Bean的全限定名

2. Bean标签的范围配置

scope属性： 对象的作用范围，有以下取值：

1. singleton：默认值，单例
2. prototype：多例
3. request：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
4. session：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
5. global session：WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

PS：

• 当值为singleton时：
  • Bean的实例化个数只有一个
  • 当Spring核心文件被加载时，Bean实例被实例化
  • 生命周期：
    • 对象创建：应用加载，创建容器时，对象被创建
    • 对象运行：容器存活，对象就存在
    • 对象销毁：应用卸载，容器销毁，对象被销毁
• 当值为prototype时：
  • Bean的实例化个数有多个
  • 当调用getBean方法时，Bean实例被实例化
  • 生命周期：
    • 对象创建：使用对象时(getBean)，创建新的对象实例
    • 对象运行：对象在使用，存活
    • 对象销毁：当对象长时间不使用，被GC回收

3. Bean的生命周期配置

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

<?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.jerry.dao.impl.UserDaoImpl" init-method="init"></bean>

4. Bean的三种实例化方法

1. 使用无参构造方法实例化 => 根据无参构造方法创建对象，没有会创建失败

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

2. 工厂静态方法实例化 => 工厂的静态方法返回Bean实例

public class StaticFactoryBean {
   
	// 注意一定是静态的
    public static UserDao createUserDao(){
       
    	return new UserDaoImpl();
    }
}

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

3. 工厂实例方法实例化 => 工厂的非静态方法返回Bean实例

public class DynamicFactoryBean {
     
	public UserDao createUserDao(){
           
		return new UserDaoImpl(); 
	}
}

<!-- 因为不是静态方法，所以需要先取得该方法所在类的实例对象 -->
<bean id="factoryBean" class="com.jerry.factory.DynamicFactoryBean"/>
<!-- 通过类的实例对象 + 对象的内部方法注入所需的目标 -->
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

PS： 注意 工厂实例化 注入的都是factory-method所对应方法的返回值

5. Bean的依赖注入入门

1. 创建UserService(service层，调用dao层)，调用UserDao

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

2. 将UserServiceImpl的创建交由Spring

<bean id="userService" class="com.jerry.service.impl.UserServiceImpl"/>

3. 从Spring容器中获取UserService进行操作

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

6. Bean的依赖注入概念

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取
例如：Service层调用Dao层，我们可以交友Spring去创建，而不是每次都自己在Service层中new一个Dao层实例

7. Bean的依赖注入方式

1. 构造方法

// 正常的通过Spring获取Dao的方式
public class UserServiceImpl implements UserService {
   
	@Override
	public void save() {
   
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");       
	    UserDao userDao = (UserDao) applicationContext.getBean("userDao");    
	    userDao.save();
	}
 }

<!-- 将userDao注入到userService中，先要将userDao交由Spring创建 -->
<bean id="userDao" class="com.jerry.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.jerry.service.impl.UserServiceImpl">
	<!-- name是构造方法的属性，ref是引用Spring容器的id值 -->      		   	
	<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

// 配置bean依赖注入之后
public class UserServiceImpl implements UserService {
   
	private UserDao userDao;
	public UserServiceImpl(UserDao userDao){
    
		// 这个形参userDao和上面的constructor-arg的name属性一致
		this.userDao = userDao;
	}
	@Override
	public void save() {
   
		// 上面的获取就不需要了，注入之后相当于直接配置好了
	    userDao.save();
	}
 }

2. set方法

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

<bean id="userDao" class="com.jerry.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.jerry.service.impl.UserServiceImpl">
	<!-- 这个name属性的值要和java代码的set方法后半部分的一致 -->
	<!-- 例如上面是setUserDao，后半部分为UserDao，首字母小写即为name填写的值 -->
	<property name="userDao" ref="userDao"/>
</bean>

PS：
set方法可以用p命名空间注入
p命名空间本质也是set方法注入，只是方便了一点
在xml中引入p命名空间，之后修改注入方式

xmlns:p="http://www.springframework.org/schema/p"
<!-- 上面的name属性是什么，就是xxx-ref -->
<bean id="userService" class="com.jerry.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

8. Bean的依赖注入的数据类型

之前用的都是自定义的类，为引用类型
注入数据可以有三种数据类型：

1. 普通数据类型
2. 引用数据类型
3. 集合数据类型

普通数据类型的注入

public class UserDaoImpl implements UserDao {
   
	private String name;
    private int age;
    public void setCompany(String name) {
   
        this.name= name;
    }
    public void setAge(int age) {
   
        this.age = age;
    }
    public void save() {
   
        System.out.println(name + ":" + age);
        System.out.println("UserDao save method running....");   
    }
}

<bean id="userDao" class="com.jerry.dao.impl.UserDaoImpl">
    <property name="name" value="xyr"></property>
    <property name="age" value="18"></property>
</bean>

集合类型的注入

1. List类型的注入

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