Spring学习笔记
Proxy （代理）
静态代理
静态代理只需写一个静态代理类就可以了
package com.bjsxt.spring;
public class UserManagerImplProxy implements UserManager {
private UserManager userManager;
public UserManagerImplProxy(UserManager userManager) {
this .userManager = userManager;
}
public void addUser(String username, String password) {
checkSecurity();
this .userManager.addUser(username, password);
}
public void deleteUser(int id) {
checkSecurity();
this .userManager.deleteUser(id);
}
public String findUserById(int id) {
return null ;
}
public void modifyUser(int id, String username, String password) {
}
private void checkSecurity() {
System.out .println("----------checkSecurity()---------------");
}
}
客户端代码
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.addUser("张三", "123");
动态代理
动态代理的话就要写一个Handler，通过Handler来生成管理类的代理
package com.bjsxt.spring;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class SecurityHandler implements InvocationHandler {
private Object targetObject;
public Object newProxy(Object targetObject) {
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
checkSecurity();
Object ret = null;
try {
ret = method.invoke(this.targetObject, args);
}catch(Exception e) {
e.printStackTrace();
throw new java.lang.RuntimeException(e);
}
return ret;
}
private void checkSecurity() {
System.out.println("----------checkSecurity()---------------");
}
}
客户端代码
SecurityHandler handler = new SecurityHandler();
UserManager userManager = (UserManager)handler.newProxy(new UserManagerImpl());
userManager.addUser("张三", "123");
spring Bean 的作用域
scope可以取值：
* singleton:每次调用getBean的时候返回相同的实例
* prototype:每次调用getBean的时候返回不同的实例
<bean id="XX " class=" " scope="prototype" />
或者
<bean id="XX " class=" " scope=" singleton " />
五、整合
Spring + Hibernate
采用编程式事务
1、getCurrentSession()与openSession()的区别？
* 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()
创建的session则不会
* 采用getCurrentSession()创建的session在commit或rollback 时会自动关闭，而采用openSession()
创建的session必须手动关闭
2、使用getCurrentSession()需要在hibernate .cfg .xml 文件中加入如下配置：
* 如果使用的是本地事务（jdbc 事务）
<property name="hibernate .current_session_context_class">thread</property>
* 如果使用的是全局事务（jta 事务）
<property name="hibernate .current_session_context_class">jta </property>
如
<!-- 使用getcurrentsession 方法的配置 -->
<!--
使用getCurrentSession()需要在hibernate .cfg .xml 文件中加入如下配置：
* 如果使用的是本地事务（jdbc 事务）
<property name="hibernate .current_session_context_class">thread</property>
* 如果使用的是全局事务（jta 事务）
<property name="hibernate .current_session_context_class">jta </property>
-->
采用声明式事务
1、声明式事务配置
* 配置SessionFactory
* 配置事务管理器
* 事务的传播特性
* 那些类那些方法使用事务
2、编写业务逻辑方法
* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是
Hibernate Session的轻量级封装
* 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会回滚的
* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理
* 关于事务边界的设置，通常设置到业务层(Manager)，不要添加到Dao 上
3、了解事务的几种传播特性
1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,
则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
4、Spring事务的隔离级别
1. ISOLATION_DEFAULT：这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
另外四个与JDBC的隔离级别相对应
2. ISOLATION_READ_UNCOMMITTED：这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
这种隔离级别会产生脏读，不可重复读和幻像读。
3. ISOLATION_READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据
4. ISOLATION_REPEATABLE_READ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
除了防止脏读，不可重复读外，还避免了幻像读。
配置声明式事务
<?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: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-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd" >
<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >
<property name="configLocation" >
<value>classpath:hibernate.cfg .xml </value>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" >
<property name="sessionFactory" >
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置事务的传播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager" >
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="modify*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- 那些类的哪些方法参与事务 -->
<aop:config>
<aop:pointcut id="allManagerMethod" expression="execution(* com.bjsxt.usermgr.manager.*.*(..))" />
<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice" />
</aop:config>
</beans>
通过他来获得seesion factory
<bean id="logManager" class="com.bjsxt.usermgr.manager.LogManagerImpl" >
<property name="sessionFactory" ref="sessionFactory" />
</bean>
Spring + Struts
spring+struts 的集成(第一种集成方案)
原理：在Action中取得BeanFactory对象，然后通过BeanFactory获取业务逻辑对象
1、spring和struts依赖库配置
* 配置struts
--拷贝struts类库和jstl 类库
--修改web.xml 文件来配置ActionServlet
--提供struts-config .xml 文件
--提供国际化资源文件
* 配置spring
--拷贝spring类库
--提供spring配置文件
2、在struts的Action中调用如下代码取得BeanFactory
BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext());
3、通过BeanFactory取得业务对象，调用业务逻辑方法
Action里的
//// 1.直接使用，没有使用spring
// UserManager userManager = new UserManagerImpl();
// userManager.login(laf .getUsername(), laf .getPassword());
//// 2.使用spring的重量级的工厂
// BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext-beans.xml ");
// UserManager userManager = (UserManager)factory.getBean("userManager");
// userManager.login(laf .getUsername(), laf .getPassword());
// 3.使用web.xml 来配置listener来读取配置文件来创建工厂
BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext (request.getSession().getServletContext());
//ApplicationContext继承beanfactory ，所以不用强制转化，也可以使用下面的活动工厂
//ApplicationContext pc = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext());
UserManager userManager = (UserManager)factory.getBean("userManager");
userManager.login(laf.getUsername(), laf.getPassword());
return mapping.findForward("success");
web.xml里的配置（添加部分）
<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>
spring+struts 的集成(第二种集成方案)
原理：将业务逻辑对象通过spring注入到Action中，从而避免了在Action类中的直接代码查询
1、spring和struts依赖库配置
* 配置struts
--拷贝struts类库和jstl 类库
--修改web.xml 文件来配置ActionServlet
--提供struts-config .xml 文件
--提供国际化资源文件
* 配置spring
--拷贝spring类库
--提供spring配置文件
2、因为Action需要调用业务逻辑方法，所以需要在Action中提供setter方法，让spring将业务逻辑对象注入过来
3、在struts-config .xml 文件中配置Action
* <action>标签中的type属性需要修改为org .springframework .web.struts.DelegatingActionProxy
DelegatingActionProxy是一个Action，主要作用是取得BeanFactory，然后根据<action>中的path属性值
到IoC容器中取得本次请求对应的Action
4、在spring配置文件中需要定义struts的Action,如：
<bean name="/login" class="com .bjsxt .usermgr .actions.LoginAction" scope="prototype">
<property name="userManager" ref ="userManager"/>
</bean>
* 必须使用name属性，name属性值必须和struts-config .xml 文件中<action>标签的path属性值一致
* 必须注入业务逻辑对象
* 建议将scope设置为prototype,这样就避免了struts Action的线程安全问题
<bean name="/login" class="com.bjsxt.usermgr.actions.LoginAction" scope="prototype" >
<property name="userManager" ref="userManager" />
</bean>
<!--type不是以前的类了，是代理类了 -->
<action path="/login"
type="org.springframework.web.struts.DelegatingActionProxy"
name="loginForm"
scope="request"
>
<forward name="success" path="/success.jsp" />
</action>
</action-mappings>
Spring + Struts + Hibernate （SSH）
整合上面的SH + SS，就可以了，本人这部分也不是很熟练，先就不写了
六、写在最后
刚学了一点关于Spring的东西，里面也仅是总结，并没有其他一些自己的思想，总结出来为了我以后跟好地学习。