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的东西，里面也仅是总结，并没有其他一些自己的思想，总结出来为了我以后跟好地学习。