spring

HeChuangJun约 4457 字大约 15 分钟

spring

1. spring介绍
4. spring框架使用
5. spring与junit整合测试（常用）
6. applicationContext.xml配置详解
7. spring创建对象的方式
8. SpringAOP
9. spring整合JDBC
10. spring事务
11. spring web项目配置
12. spring整合struts2
13. spring整合c3p0连接池
14. spring整合hibernate
15. spring的java配置多数据源
16. Spring4.x的Java配置方式（可以完全替代xml配置）
17. spring4.x配置数据库连接池
spring不同类型的事件？

1. spring介绍

spring框架性质是属于容器性质的.容器中装什么对象就有什么功能.所以可以一站式.不仅不排斥其他框架,还能帮其他框架管理对象.
aop支持\ioc思想'\spring jdbc\aop 事务\junit 测试支持

4. spring框架使用

xml配置
导包
com.springsource.org.apache.log4j-1.2.15.jar可选
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar

com.springsource.org.apache.commons.logging-1.1.1.jar日志包

创建一个对象，set/get方法
在src下的applicationContext.xml中导入约束beans约束,并注册对象
<bean name="" class=""/>
代码测试
@Test
public void fun(){
	ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	User u = ac.getBean("user");
}

注解配置
导包一样
配置applicationContext.xml开启使用注解代理
导入约束spring-context-4.2.xsd
指定扫描该com.junye.bean包及子孙包下所有类中的注解
<context:component-scan base-package="com.junye.bean"></context>
在类中使用注解完成配置
将对象注册到容器四个注解没区别，唯一区分就是分层，推荐使用最后三个
@component("user")
@Controller("user")//web层
@Service("user")//service层
@Repository("user")//dao层

修改对象的作用范围(struts中的Action是多例的才线程安全，单例不安全)
@Scope(scopeName="prototype")	

值类型注入
@Value("tom")//通过反射的Field赋值,破坏了封装性
private String name;
通过set方法赋值,推荐使用.
@Value("tom")
public void setName(String name){
	this.name=name;
}

引用类型注入
@Autowired//自动装配,如果匹配多个类型一致的对象，将无法选择注入那个对象
@Qualifier("car2")告诉spring容器自动装配那个名称的对象
private Car car;
@Resource(name="car")手动注入，指定注入那个对象
private Car car;

初始化|销毁方法
@PostConstruct//在对象被创建后调用。init-method
public voud init(){}
@PreDestroy//在销毁之前调用。destory-method
public void destory(){}

5. spring与junit整合测试（常用）

导包
com.springsource.org.apache.log4j-1.2.15.jar可选
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
spring-aop-4.2.4.RELEASE.jar

spring-test-4.2.4.RELEASE.jar

配置注解与测试
@RunWith(SpringJUnit4ClassRunner.class)		
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo{
	@Resource(name="user")
	private User u;
	
	@Test
	public void fun1(){
		System.out.println("测试");
	}
}

6. applicationContext.xml配置详解

<!-- 
Bean元素：描述需要spring容器管理的对象
class属性:被管理对象的完整类名.
name属性:命名被管理的对象.获得对象时根据该名称获得对象.可重复.可用特殊字符（推荐）
id属性: 与name属性一模一样. 名称不可重复.不能使用特殊字符. 
scope属性(整合struts2时,ActionBean必须配置为多例的)
	singleton(默认值):单例对象.被标识为单例的对象在spring容器中只会存在一个实例
	prototype:多例原型.被标识为多例的对象,每次再获得才会创建.每次创建都是新的对象.
	request:web环境下.对象与request生命周期一致.
	session:web环境下,对象与session生命周期一致. 
生命周期属性(需要在相应的类中实现其方法)
	配置生命周期初始化方法.spring会在对象创建之后立即调用.init-method
	配置生命周期的销毁方法.spring容器在关闭并销毁所有容器中的对象之前调用.destory-method	
-->
<bean  id="user" name="user" class="cn.bean.User" scope="singleton" init-method="init" destroy-method="destroy"></bean>
<!-- spring的分模块配置(导入其他spring配置文件) -->
<import resource="cn/b_create/applicationContext.xml"/>

7. spring创建对象的方式

空参构造方式
<bean name="junye" class="cn.junye.hello.Junye"></bean>

静态工厂(了解)不需创建即可用类名调用静态方法
public class UserFactory{
	public static User createUser(){
		System.out.println("静态工厂创建User");
		return new User();
	}
}
<bean name="userFactory" class="cn.junye.hello.UserFactory" factory-method="createUser"></bean>

实例工厂(了解)
public  User fun(){
	System.out.println("实例工厂创建User");
	return new User();	
}
<!-- 调用UserFactory对象的createUser2方法创建名为user3的对象.放入容器-->
<bean  name="user3" factory-bean="userFactory" factory-method="fun"></bean>
<bean  name="userFactory" class="cn.b_create.UserFactory" </bean>

8. SpringAOP

xml配置
导包
com.springsource.org.apache.log4j-1.2.15.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
spring的aop包
spring-aspects-4.2.4.RELEASE.jar
spring-aop-4.2.4.RELEASE.jar
spring需要的第三方aop包
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

目标对象(接口实现关系)
public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		System.out.println("保存用户!");
	}
}

准备通知类
public class MyAdvice {
	//前置通知:目标方法运行之前调用
	public void before(){
		System.out.println("这是前置通知!!");
	}
	//环绕通知:在目标方法之前和之后都调用
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//后置通知:在目标方法运行之后调用(如果出现异常不会调用)
	public void afterReturning(){
		System.out.println("这是后置通知(如果出现异常不会调用)!!");
	}
	//后置通知:在目标方法运行之后调用(无论是否出现 异常都会调用)
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
	//异常通知:如果出现异常,就会调用
	public void afterException(){
		System.out.println("出事啦!出现异常了!!");
	}
}
配置applicationContext.xml,将通知织入目标对象中
//导入aop约束
<!-- 1.配置目标对象 -->
<bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>

<!-- 2.配置通知对象 -->
<bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean>

<aop:config><!--执行顺序为下面那个-->
	<aop:pointcut expression="execution(* cn.service.*ServiceImpl.*(..))" id="pc"/>
	<aop:aspect ref="myAdvice" >
		<aop:before method="before" pointcut-ref="pc" />
		<aop:around method="around" pointcut-ref="pc" />
		<aop:after-returning method="afterReturning" pointcut-ref="pc" />
		<aop:after method="after" pointcut-ref="pc"/>
		<aop:after-throwing method="afterException" pointcut-ref="pc"/>
	</aop:aspect>
</aop:config>

<!-- 配置切入点 ，配置要被切的方法通常在service层

public void cn.itcast.service.UserServiceImpl.save() 
void cn.itcast.service.UserServiceImpl.save()
* cn.itcast.service.UserServiceImpl.save()
* cn.itcast.service.UserServiceImpl.*()

* cn.itcast.service.*ServiceImpl.*(..)包括一到多的参数
* cn.itcast.service..*ServiceImpl.*(..)包括所有的子包 -->
测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
	@Resource(name="myAop")
	private MyAop us;接口
	@Test
	public void fun1(){
		us.save();
	}
}

注解配置
导包(一样)
开启使用注解完成织入
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
准备目标对象(一样)	
准备通知(一样)配置目标对象和通知对象（xml中）一样
配置进行织入,将通知织入目标对象中
//通知类
@Aspect
//表示该类是一个通知类
public class MyAdvice {
	@Pointcut("execution(* cn.itcast.service.*ServiceImpl.*(..))")
	public void pc(){}
	//前置通知
	//指定该方法是前置通知,并制定切入点
	@Before("MyAdvice.pc()")
	public void before(){
		System.out.println("这是前置通知!!");
	}
	//后置通知
	@AfterReturning("execution(* cn.itcast.service.*ServiceImpl.*(..))")
	public void afterReturning(){
		System.out.println("这是后置通知(如果出现异常不会调用)!!");
	}
	//环绕通知
	@Around("execution(* cn.itcast.service.*ServiceImpl.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//异常通知
	@AfterThrowing("execution(* cn.itcast.service.*ServiceImpl.*(..))")
	public void afterException(){
		System.out.println("出事啦!出现异常了!!");
	}
	//后置通知
	@After("execution(* cn.itcast.service.*ServiceImpl.*(..))")
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}
@before（Myadvice.pc()指寻找Myadvice的pc方法的pointcut注释，与pc这个方法内容无关）

9. spring整合JDBC

spring提供了很多模板整合Dao技术
spring中提供了一个可以操作数据库的对象.对象封装了jdbc技术.
JDBCTemplate => JDBC模板对象与DBUtils中的QueryRunner非常相似.

导包
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.apache.log4j-1.2.15.jar
mysql-connector-java-5.1.7-bin.jar
spring-aop-4.2.4.RELEASE.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
spring-jdbc-4.2.4.RELEASE.jar
spring-test-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar

准备数据库
application.xml的配置

JdbcTemplate依赖dataSource，UserDao依赖JdbcTemplate

<context:property-placeholder location="classpath:db.properties"  />
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
	<property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
	<property name="driverClass" value="${jdbc.driverClass}" ></property>
	<property name="user" value="${jdbc.user}" ></property>
	<property name="password" value="${jdbc.password}" ></property>
</bean>
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
	<property name="dataSource" ref="dataSource" ></property>
</bean>
<bean name="userDao" class="cn.itcast.a_jdbctemplate.UserDaoImpl" >
	<property name="jt" ref="jdbcTemplate" ></property>
</bean>

测试
③1、Dao实现类通过定义private JdbcTemplate jt和set方法操作数据库
2、Dao实现类继承jdbcDaoSupport通过super.getJdbcTemplate()操作数据库
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
	@Override
	public void save(User u) {
		String sql = "insert into t_user values(null,?) ";
		super.getJdbcTemplate().update(sql, u.getName());
	}
	@Override
	public void delete(Integer id) {
		String sql = "delete from t_user where id = ? ";
		super.getJdbcTemplate().update(sql,id);
	}
	@Override
	public void update(User u) {
		String sql = "update  t_user set name = ? where id=? ";
		super.getJdbcTemplate().update(sql, u.getName(),u.getId());
	}
	@Override
	public User getById(Integer id) {
		String sql = "select * from t_user where id = ? ";
		return super.getJdbcTemplate().queryForObject(sql,new RowMapper<User>(){
	@Override
	public User mapRow(ResultSet rs, int arg1) throws SQLException {
		User u = new User();
		u.setId(rs.getInt("id"));
		u.setName(rs.getString("name"));
		return u;
		}}, id);
	}
	@Override
	public int getTotalCount() {
		String sql = "select count(*) from t_user  ";
		Integer count = super.getJdbcTemplate().queryForObject(sql, Integer.class);
		return count;
	}

	@Override
	public List<User> getAll() {
		String sql = "select * from t_user  ";
		List<User> list = super.getJdbcTemplate().query(sql, new RowMapper<User>(){
		@Override
		public User mapRow(ResultSet rs, int arg1) throws SQLException {
			User u = new User();
			u.setId(rs.getInt("id"));
			u.setName(rs.getString("name"));
			return u;
		}});
	return list;
	}
}

10. spring事务

xml配置(aop)
导包
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.apache.log4j-1.2.15.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
mysql-connector-java-5.1.7-bin.jar
spring-aop-4.2.4.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
spring-jdbc-4.2.4.RELEASE.jar
spring-test-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar				

application.xml配置
<!-- 导入新的约束(tx)
beans: 最基本
context:读取properties配置
aop:配置aop
tx:配置事务通知 -->
<!-- 将核心事务管理器配置到spring容器 -->
<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
	<property name="dataSource" ref="dataSource" ></property>
</bean>

<!-- 配置通知（环绕通知）会改写数据库的语句增加了read-only的话会报错-->
<tx:advice id="txAdvice" transaction-manager="transactionManager" >
	<tx:attributes>
		<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
	</tx:attributes>
</tx:advice>

<!--配置将通知织入目标-->
<aop:config>
	<aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.service.*.*(..))" />
</aop:config>
或者
<!-- 配置织入 -->
<aop:config  >
	<!-- 配置切点表达式 -->
	<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="txPc"/>
	<!-- 配置切面 : 通知+切点 advice-ref:通知的名称pointcut-ref:切点的名称-->
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config>

注解配置(aop)
导包（一样）
导入新的约束(tx)(一样)
将核心事务管理器配置到spring容器(一样)
开启注解管理事务<tx:annotation-driven/>
在类或方法上面配置注解
- @Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=true)

11. spring web项目配置

导包(41个)
创建配置文件applicationContext.xml,并导入约束(4个)beans|context|aop|tx
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-4.2.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
</beans>

配置spring随项目启动(web.xml)
<!-- 让spring随web启动而创建的监听器 -->
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置spring配置文件位置参数 -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:applicationContext.xml</param-value>
</context-param>

12. spring整合struts2

导包
struts.xml配置常量
在/struts2-spring-plugin-2.3.24.jar/struts-plugin.xml
struts.objectFactory = spring	将action的创建交给spring容器(已开)
<constant name="struts.objectFactory" value="spring"></constant>

在/struts2-core-2.3.24.jar/default.properties	
struts.objectFactory.spring.autoWire = name spring负责装配Action依赖属性(已开)

	配置struts2主配置文件struts.xml并倒入约束
	<?xml version="1.0" encoding="UTF-8"?>
	<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
		<package name="crm" namespace="/" extends="struts-default" >
			<!-- class属性上填写spring中action对象的BeanName完全由spring管理action生命周期,包括Action的创建 注意:需要手动组装依赖属性
			struts.xml，Action中的属性不组装则为null-->
			<action name="UserAction_*" class="userAction" method="{1}" >
				<result name="toHome" type="redirect" >/index.htm</result>
				<result name="error" >/login.jsp</result>
			</action>
		</package>
	</struts>


配置applicationContext.xml

<!-- 注意:Action对象作用范围一定是多例的.这样才符合struts2架构 -->
<bean name="userAction" class="cn.action.UserAction" scope="prototype" >
	<property name="userService" ref="userService" ></property>
</bean>

配置struts2核心过滤器到web.xml
<filter>
	<filter-name>struts2</filter-name>
	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
	<filter-name>struts2</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

13. spring整合c3p0连接池

配置db.properties
jdbc.jdbcUrl=jdbc:mysql:///crm_32
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=1234

引入连接池到spring中
	<!-- 读取db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" />
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
		<property name="driverClass" value="${jdbc.driverClass}" ></property>
		<property name="user" value="${jdbc.user}" ></property>
		<property name="password" value="${jdbc.password}" ></property>
	</bean>


	将连接池注入给SessionFactory
	<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
	<!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
	<property name="dataSource" ref="dataSource" ></property>

14. spring整合hibernate

导入实体类&orm元数据
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="" >
	<class name="" table="" >
	<id name="" column="" >
		<generator class="native|assigned|uuid|increment|hilo|identity|sequence"></generator>
	</id>
	<property name="" column="" ></property>

	<set name="" inverse="true|false" cascade="save-update|delete|all" 
	lazy="true|false|extra" fetch="select/join/subselect" batch-size="3">
	<key column="" ></key>
		<one-to-many class="" />
	</set>
	<many-to-one name="" column="" class="" inverse="false|true" cascade="save-update|delete|all" 
		lazy="false/proxy" fetch="select/join">
	</many-to-one>

	<set name="" table="" inverse="true|false" cascade="save-update|delete|all"
		lazy="true|false|extra" fetch="select/join/subselect">
		<key column="" ></key>
		<many-to-many class="" column="" ></many-to-many>
	</set>
	</class>
</hibernate-mapping>

在spring配置中放置hibernate配置信息
//将sessionFactory交给spring代替配置主配置文件
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
<!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
	<property name="dataSource" ref="dataSource" ></property>
	<property name="hibernateProperties">
	<props>
		<prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
		<prop key="hibernate.connection.url" >jdbc:mysql:///crm</prop>
		<prop key="hibernate.connection.username" >root</prop>
		<prop key="hibernate.connection.password" >1234</prop> -->
		<prop key="hibernate.dialect" >org.hibernate.dialect.MySQL5Dialect</prop>

		<prop key="hibernate.show_sql" >true</prop>
		<prop key="hibernate.format_sql" >true</prop>
		<prop key="hibernate.hbm2ddl.auto" >update</prop>
	</props>
	<!-- ①引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
	</property>
		<property name="mappingDirectoryLocations" value="classpath:cn/itcast/domain" >
	</property>
	<!--②引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置-->
	<!--<property name="mappingLocations">
		<list>
			<value>classpath:com/itheima/bos/domain/*.xml</value>
		</list>
	</property>-->
</bean>

<!-- 为dao注入sessionFactory -->
<bean name="userDao" class="cn.itcast.dao.impl.UserDaoImpl" >
	<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>

hibernate操作数据库

dao实现类继承HibernateDaoSupport操作HIbernateTemplate
增删改
this.getHibernateTemplate().save(entity);
this.getHibernateTemplate().delete(entity);
this.getHibernateTemplate().update(entity);
this.getHibernateTemplate().get(entityClass, id);

spring中hibernate的aop事务

配置事务管理器(xml和注解都要配置)
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager" >
	<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>

1、xml配置aop事务
配置通知
<tx:advice id="txAdvice" transaction-manager="transactionManager" >
	<tx:attributes>
		<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
	</tx:attributes>
</tx:advice>


配置将通知织入目标对象，配置切点，配置切面 
<aop:config>
	<aop:pointcut expression="execution(* com.serviceimpl.*ServiceImpl.*(..))" id="txPc"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config> 

2、注解配置aop事务
开启注解事务<tx:annotation-driven transaction-manager="transactionManager" />	


Service类、方法中使用注解
@Transactional(isolation=Isolation.REPEATABLE_READ,
propagation=Propagation.REQUIRED,readOnly=false)					

为了避免使用懒加载时出现no-session问题.需要扩大session的作用范围
注意: 任何filter一定要在struts的filter之前调用，在struts2过滤器前面
配置web.xml
<filter>
	<filter-name>openSessionInView</filter-name>
	<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
	<filter-name>openSessionInView</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

15. spring的java配置多数据源

16. Spring4.x的Java配置方式（可以完全替代xml配置）

	编写SpringConfig 用于实例化Spring容器，整个文件相当于applicationContext.xml
	@Configuration //通过该注解来表明该类是一个Spring的配置，相当于一个xml文件
		@ComponentScan(basePackages = "cn.itcast.springboot.javaconfig") //配置扫描包，扫描组件
		//@PropertySource可以指定读取的配置文件，通过@Value注解获取值
		@PropertySource(value= {"classpath:jdbc.properties","xxxx"},ignoreResourceNotFound=true)
		public class SpringConfig {
		@Value("${jdbc.url}")
		private String jdbcUrl;	
		@Bean // 通过该注解来表明是一个Bean对象，相当于xml中的<bean>
		public UserDAO getUserDAO(){
			return new UserDAO(); // 直接new对象做演示
		}
	}

17. spring4.x配置数据库连接池

	导入依赖：
		<!-- 连接池 -->
		<dependency>
		<groupId>com.jolbox</groupId>
		<artifactId>bonecp-spring</artifactId>
		<version>0.8.0.RELEASE</version>
		</dependency>

	xml配置改造成java配置方式：
	@Value("${jdbc.url}")
		private String jdbcUrl;

		@Value("${jdbc.driverClassName}")
		private String jdbcDriverClassName;

		@Value("${jdbc.username}")
		private String jdbcUsername;

		@Value("${jdbc.password}")
		private String jdbcPassword;

		@Bean(destroyMethod = "close")
		public DataSource dataSource() {
		BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
		boneCPDataSource.setDriverClass(jdbcDriverClassName);
		boneCPDataSource.setJdbcUrl(jdbcUrl);
		boneCPDataSource.setUsername(jdbcUsername);
		boneCPDataSource.setPassword(jdbcUsername);
		// 检查数据库连接池中空闲连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0
		boneCPDataSource.setIdleConnectionTestPeriodInMinutes(60);
		// 连接池中未使用的链接最大存活时间，单位是分，默认值：60，如果要永远存活设置为0
		boneCPDataSource.setIdleMaxAgeInMinutes(30);
		// 每个分区最大的连接数
		boneCPDataSource.setMaxConnectionsPerPartition(100);
		// 每个分区最小的连接数    
		boneCPDataSource.setMinConnectionsPerPartition(5);
		return boneCPDataSource;
		}

spring不同类型的事件？

Spring 的 ApplicationContext 提供了支持事件和代码中监听器的功能,Spring 提供了以下五种标准的事件：

//监听系统事件
上下文更新事件（ContextRefreshedEvent）：该事件会在ApplicationContext 被初始化或者更新时发布。也可以在调用ConfigurableApplicationContext 接口中的 #refresh() 方法时被触发。
上下文开始事件（ContextStartedEvent）：当容器调用ConfigurableApplicationContext 的 #start() 方法开始/重新开始容器时触发该事件。
上下文停止事件（ContextStoppedEvent）：当容器调用 ConfigurableApplicationContext 的 #stop() 方法停止容器时触发该事件。
上下文关闭事件（ContextClosedEvent）：当ApplicationContext 被关闭时触发该事件。容器被关闭时，其管理的所有单例 Bean 都被销毁。
请求处理事件（RequestHandledEvent）：在 We b应用中，当一个HTTP 请求（request）结束触发该事件。
public class AllApplicationEventListener implements ApplicationListener<ApplicationEvent> {  
    @Override  
    public void onApplicationEvent(ApplicationEvent applicationEvent) {}
}
//自定义事件
public class CustomApplicationEvent extends ApplicationEvent{  
    public CustomApplicationEvent(Object source, final String msg) {  
        super(source);
    }  
}
//监听自定义事件
public class CustomEventListener implements ApplicationListener<CustomApplicationEvent> {
    @Override  
    public void onApplicationEvent(CustomApplicationEvent applicationEvent) {}
}
//发布自定义事件
// 创建 CustomApplicationEvent 事件
CustomApplicationEvent customEvent = new CustomApplicationEvent(applicationContext, "Test message");
// 发布事件
applicationContext.publishEvent(customEvent);

@ConditionalOnMissingBean条件注解最好在@AutoConfiguration里面的@Bean上面使用，同时将该配置类注册为自动配置类，才能保证100%生效，否则会被另外的配置类覆盖