Java进阶学习第二十二天（Spring框架）

版权声明：使用本品须Jack Gao同意，违者必究 https://blog.csdn.net/Mr_GaoYang/article/details/82788482

一、回顾

1、Struts与Hibernate可以做什么事？
① Struts：Mvc中控制层解决方案 ；可以进行请求数据自动封装、类型转换、文件上传、效验等等
② Hibernate：持久层的解决方案； 可以做到，把对象保存到数据库， 从数据库中取出的是对象

2、简单来说，spring就是处理对象的创建的、以及对象的依赖关系！

二、Spring框架

1、专业术语
① 组件/框架设计
◆ 侵入式设计：引入了框架，对现有的类的结构有影响，即需要实现或继承某些特定类。
例如： Struts框架
◆ 非侵入式设计：引入了框架，对现有的类结构没有影响。
例如：Hibernate框架 / Spring框架
② 控制反转（Inversion on Control , IOC）
◆ 对象的创建交给外部容器完成，这个就做控制反转
◆ 依赖注入， dependency injection ，处理对象的依赖关系
◆ 区别：
控制反转， 解决对象创建的问题 【对象创建交给别人】
依赖注入，在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
③ AOP：面向切面编程
切面，简单来说来可以理解为一个类，由很多重复代码形成的类。
切面举例：事务、日志、权限;

2、概述
Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架，且可以和其他框架一起使用，比如Spring与Struts、Spring与Hibernate（起到整合作用的一个框架）

Spring提供了一站式解决方案（六大模块）：
① Spring Core：spring的核心功能，IOC容器，解决对象创建及依赖关系
② Spring Web：Spring对web模块的支持
◆ 可以与struts整合，让struts的action创建交给spring
◆ spring mvc模式
③ Spring DAO：Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
④ Spring ORM：spring对orm的支持：
◆ 既可以与hibernate整合【session】
◆ 也可以使用spring的对hibernate操作的封装
⑤ Spring AOP：切面编程
⑥ SpringEE：spring 对javaEE其他模块的支持

3、开发步骤
spring各个版本中：
在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】
在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】（如果要用依赖包，需要单独下载

① 源码：jar文件：spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar             日志
spring-beans-3.2.5.RELEASE.jar        bean节点
spring-context-3.2.5.RELEASE.jar      spring上下文节点
spring-core-3.2.5.RELEASE.jar         spring核心功能
spring-expression-3.2.5.RELEASE.jar   spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以用户库管理！
② 核心配置文件：applicationContext.xml
Spring配置文件：applicationContext.xml / bean.xml
约束参考：
spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
</beans>   

③ API

public class App {
	// 1、通过工厂类得到IOC容器创建的对象
	@Test
	public void testIOC() throws Exception {
		// 现在，把对象的创建交给spring的IOC容器
		Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
		// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
		BeanFactory factory = new XmlBeanFactory(resource);
		// 得到容器创建的对象
		User user = (User) factory.getBean("user");
		System.out.println(user.getId());
	}
	
	//2、（方便）直接得到IOC容器对象 
	@Test
	public void testAc() throws Exception {
		// 得到IOC容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		// 从容器中获取bean
		User user = (User) ac.getBean("user");
		System.out.println(user);
	}
}

4、bean对象创建的细节

	/**
	 * 1) 对象创建： 单例/多例
	 * 	scope="singleton"，默认值，默认是单例	【service/dao/工具类】
	 *  scope= "prototype"，多例  			【Action对象】
	 * 
	 * 2) 什么时候创建?
	 * 	  scope="prototype"  在用到对象的时候，才创建对象。
	 *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个
	 * 
	 * 3) 是否延迟创建 （只对单例有效）
	 * 	  lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
	 * 	  lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
	 *
	 * 4) 创建对象之后，初始化/销毁
	 * 	  init-method="init_user"        【对应对象的init_user方法，在对象创建之后执行 】
	 *    destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行（容器用实现类）】
	 */
	 
	@Test
	public void testIOC() throws Exception {
		// 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		System.out.println("-----容器创建-----");
		// 从容器中获取bean
		User user1 = (User) ac.getBean("user");
		User user2 = (User) ac.getBean("user");
		System.out.println(user1);
		System.out.println(user2);	
		// 销毁容器对象 
		ac.destroy();
	}

5、SpringIOC容器
① 创建对象：SpringIOC容器，是spring核心内容。
作用： 创建对象 & 处理对象的依赖关系

IOC容器创建对象的几种方式：
◆ 调用无参数构造器
◆ 带参数构造器
◆ 工厂创建对象（静态方法创建对象、非静态方法创建对象）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
	
	<!-- ###############对象创建############### -->
	
	<!-- 1. 默认无参数构造器 
	<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
	-->  
	
	<!-- 2. 带参数构造器 -->
	<bean id="user2" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
	</bean>
	-->  
	
	<!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
	<bean id="str" class="java.lang.String">
		<constructor-arg value="Jacks"></constructor-arg>
	</bean>
	<bean id="user3" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
	</bean>
	-->  
	
	<!-- 3. 工厂类创建对象 -->
	<!-- # 3.1 工厂类，实例方法 -->
	<!-- 先创建工厂 -->
	<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
	<!-- 在创建user对象，用factory方的实例方法 -->
	<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
	
	<!-- # 3.2 工厂类： 静态方法 -->
	<!-- 
		class 指定的就是工厂类型
		factory-method  一定是工厂里面的“静态方法”
	 -->
	<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
</beans>      

② 对象依赖关系
Spring中，如何给对象的属性赋值? 【DI，依赖注入】
◆ 通过构造函数
◆ 通过set方法给属性注入值（常用）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
	
	<!-- ###############对象属性赋值############### -->
	<!--  1) 通过构造函数 -->
	<bean id="user1" class="cn.itcast.c_property.User" scope="prototype">
		<constructor-arg value="100"></constructor-arg>
		<constructor-arg value="Tom"></constructor-arg>
	</bean>
	
	<!-- 2) 通过set方法给属性注入值 -->
	<bean id="user" class="cn.itcast.c_property.User" scope="prototype">
		<property name="id" value="101"></property>
		<property name="name" value="Jack"></property>
	</bean>
	
	<!-- 案例：action/service/dao -->
	<!-- dao instance -->
	<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
	<!-- service instance -->
	<bean id="userService" class="cn.itcast.c_property.UserService">
		<property name="userDao" ref="userDao"></property>
	</bean>
	<!-- action instance -->
	<bean id="userAction1" class="cn.itcast.c_property.UserAction">
		<property name="userService" ref="userService"></property>
	</bean>
	
	<!-- ##############内部bean############## -->
	<bean id="userAction2" class="cn.itcast.c_property.UserAction">
		<property name="userService">
			<bean class="cn.itcast.c_property.UserService">
				<property name="userDao">
					<bean class="cn.itcast.c_property.UserDao"></bean>
				</property>
			</bean>
		</property>
	</bean>
	
	<!-- 
		给对象属性注入值：
			# p 名称空间给对象的属性注入值
			 (spring3.0以上版本才支持)
	 -->
</beans>      

◆ p名称空间注入属性值（优化）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
	<!-- ###############对象属性赋值############### -->
	
	<!-- 
		给对象属性注入值：
			# p 名称空间给对象的属性注入值(spring3.0以上版本才支持)
	 -->
	 <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
	 <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
	 <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>	
	
	<!-- 传统的注入： 
	 <bean id="user" class="cn.itcast.c_property.User" >
	 	<property name="name" value="xxx"></property>
	 </bean>
	-->
	
	<!-- p名称空间优化后 -->
	<bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
</beans>   

◆ 自动装配（了解）
根据名称自动装配：autowire=“byName”
自动去IOC容器中找与属性名同名的引用的对象，并自动注入

<!-- ###############自动装配############### -->  
	<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>	
	<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
	<!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->
	<bean id="userAction"  class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

也可以定义到全局， 这样就不用每个bean节点都去写autowire=”byName”

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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" default-autowire="byName">   根据名称自动装配（全局）
	
	<!-- ###############自动装配############### -->  
	<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>	
	<bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
	<bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
</beans>   

根据类型自动装配：autowire=“byType”，必须确保改类型在IOC容器中只有一个对象；否则报错。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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" default-autowire="byType">
	<!-- ###############自动装配############### -->  
	<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>	
	<bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
	
	<!-- 如果根据类型自动装配： 必须确保IOC容器中只有一个该类型的对象 -->
	<bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
	
	<!--   报错： 因为上面已经有一个该类型的对象，且使用了根据类型自动装配
	<bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
	 -->
</beans>  

总结：Spring提供的自动装配主要是为了简化配置，但是不利于后期的维护（一般不推荐使用）
◆ 注解：简化spring的IOC容器的配置
使用注解步骤：
◇ 先引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
◇ 开启注解扫描
<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
◇ 使用注解
通过注解的方式，把对象加入ioc容器
创建对象以及处理对象依赖关系，相关的注解包括：

@Component    指定把一个对象加入IOC容器
@Repository   作用同@Component； 在持久层使用
@Service      作用同@Component； 在业务逻辑层使用
@Controller   作用同@Component； 在控制层使用 
@Resource     属性注入

// 把当前对象加入ioc容器
//@Component("userDao")   //  相当于bean.xml 【<bean id=userDao class=".." />】
//@Component  // 加入ioc容器的UserDao对象的引用名称， 默认与类名一样， 且第一个字母小写
@Repository   // 在持久层可以选择用这个注解
public class UserDao {	
	public UserDao(){
		System.out.println("UserDao.UserDao()");
	}
	public UserDao(int id){
		System.out.println("UserDao.UserDao(int id)" + id);
	}
	public void save() {
		System.out.println("DB:保存用户!!!");
	}
}

//@Component("userService")  // userService加入ioc容器
//@Component
@Service   // 表示业务逻辑层的组件
public class UserService {
//	@Resource					//  根据类型查找 【在容器中要确保该类型只有一个变量】
	@Resource(name = "userDao")  // 根据名称查找
	private UserDao userDao;  // 去容器中找UserDao类型的变量，找到后就赋值
	public void save() {
		userDao.save();
	}
}

//@Component("userAction")  // 加入IOC容器
//@Component
@Controller  // 控制层的组件
public class UserAction {
	@Resource
	private UserService userService;
	public String execute() {
		userService.save();
		return null;
	}
}

总结：使用注解，可以简化配置，且可以把对象加入IOC容器及处理依赖关系(DI)，并且注解可以和XML配置一起使用。

三、Spring与Struts框架整合

1、Spring，负责对象对象创建

2、Struts， 用Action处理请求

3、关键点：让struts框架action对象的创建，交给spring完成

4、SSH整合
◆ Spring与Struts关键点： action交给spring创建!
◆ Spring与Hibernate关键点： sessionFactory对象交给spring创建！

5、步骤
◆ 引入jar文件
◇ 引入struts .jar相关文件（9个）
◇ spring-core相关jar文件（5个）
◇ spring-web的支持jar包
spring-web-3.2.5.RELEASE.jar 【Spring源码】
struts2-spring-plugin-2.3.4.1.jar 【Struts源码】
◆ 配置XML
◇ struts.xml 【struts路径与action映射配置】
◇ bean.xml 【spring ioc容器配置】
◇ web.xml 【通过核心过滤器引入struts功能、初始化spring的ioc容器】