spring2总结(20-30)

    }

服务器调用类

 

SecurityHandler handler = new SecurityHandler();

       //把接口传递过去

       UserManager userManager = (UserManager)handler.newProxy(new UserManagerImpl());

      

       //userManager.addUser("张三", "123");

       userManager.deleteUser(1);

 

十、aop

spring对AOP的只是（采用Annotation注解的方式）

1、spring依赖库

    * SPRING_HOME/dist/spring.jar

    * SPRING_HOME/lib/jakarta-commons/commons-logging.jar

    * SPRING_HOME/lib/log4j/log4j-1.2.14.jar

    * SPRING_HOME/lib/aspectj/*.jar

 

在检查安全性的类中

/**

 * 定义Aspect切面

 * @author Administrator

 *

 */

@Aspect

public class SecurityHandler {

   

    /**

     * 定义Pointcut,Pointcut的名称就是allAddMethod，此方法不能有返回值和参数，该方法只是一个

     * 标识

     * 第一个参数是返回值

     * Pointcut的内容是一个表达式，描述那些对象的那些方法（订阅Joinpoint）

     */

    @Pointcut("execution(* add*(..)) || execution(* del*(..))")

    private void allAddMethod(){};

   

    /**

     * 定义Advice，标识在那个切入点何处织入此方法

     */

    @Before("allAddMethod()")

    private void checkSecurity() {

       System.out.println("----------checkSecurity()---------------");

    }

 

在IOC容器中配置

//启用注解的支持

<aop:aspectj-autoproxy/>

//Spring管理的对象

<bean id="securityHandler" class="com.bjsxt.spring.SecurityHandler"/>          

    <bean id="userManager" class="com.bjsxt.spring.UserManagerImpl"/>

 

客户端调用

public static void main(String[] args) {

       BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");

      

       UserManager userManager = (UserManager)factory.getBean("userManager");

      

       userManager.addUser("张三", "123");

       userManager.deleteUser(1);

 

补充说明：

AOP:

    * Cross cutting concern横切性关注点

    * Aspect切面横切性关注点模块化

    * Advice横切性关注点具体实现

    * Pointcut切入的实现方法或表达式

    * Joinpoint切入的具体实现方法

    * Weave应用到方法的过程

    * Target Object：另外直入的方法真实实现

    * Proxy：产生的代理

    * Introduction动态的增加方法

 

 

十二、采用静态配置文件的方式实现aop

 

写一个切面类

public class SecurityHandler {

   

    private void checkSecurity() {

       System.out.println("----------checkSecurity()---------------");

    }

 

IOC容器中配置

 

<bean id="securityHandler" class="com.bjsxt.spring.SecurityHandler"/>          

   

    <bean id="userManager" class="com.bjsxt.spring.UserManagerImpl"/>

    <!-- id只是一个标识 -->

    <aop:config>

    <!-- pointcut也可以定义在这里 -->

       <aop:aspect id="security" ref="securityHandler">

           <aop:pointcut id="allAddMethod" expression="execution(* com.bjsxt.spring.UserManagerImpl.add*(..))"/>

           <!-- 应用于那个方法 -->

           <aop:before method="checkSecurity" pointcut-ref="allAddMethod"/>

       </aop:aspect>

    </aop:config>

 

客户端和上面一样

 

十三，获取拦截差数

 

在检查安全性的类中

 

public class SecurityHandler {

   

    private void checkSecurity(JoinPoint joinPoint) {

//获取差数

       Object[] args = joinPoint.getArgs();

       for (int i=0; i<args.length; i++) {

           System.out.println(args[i]);

       }

       //获取方法名

       System.out.println(joinPoint.getSignature().getName());

       System.out.println("----------checkSecurity()---------------");

    }

}

 

十四、jdk的动态代理和字节码生成

spring对AOP的支持

 

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

 

 

如何强制使用CGLIB实现AOP？

    * 添加CGLIB库，SPRING_HOME/cglib/*.jar

    * 在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

   

JDK动态代理和CGLIB字节码生成的区别？

    * JDK动态代理只能对实现了接口的类生成代理，而不能针对类

    * CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

      因为是继承，所以该类或方法最好不要声明成final  

 

十五、hibernate编程式事务

 

建立工厂模式

 

public class HibernateUtils {

 

    private static SessionFactory factory;

   

    static {

       try {

           Configuration cfg = new Configuration().configure();

           factory = cfg.buildSessionFactory();

       }catch(Exception e) {

           e.printStackTrace();

       }

    }

   

    public static SessionFactory getSessionFactory() {

       return factory;

    }

   

    public static Session getSession() {

       return factory.openSession();

    }

   

    public static void closeSession(Session session) {

       if (session != null) {

           if (session.isOpen()) {

              session.close();

           }

       }

    }

 

一般方式调用类

public class UserManagerImpl implements UserManager {

 

    public void addUser(User user) {

       Session session = null;

       try {

           //session = HibernateUtils.getSession();

//采用获取当前线程的方法hibernate3.x有这样的方法，而不用传递

Session到其他方法理了如

//--------------------------------------

    public void addLog(Log log) {

       HibernateUtils.getSessionFactory().getCurrentSession().save(log);

    }

//--------------------------------------

//不用关闭事务，当提交或回滚时候自动关闭

           session = HibernateUtils.getSessionFactory().getCurrentSession();

           session.beginTransaction();

          

           session.save(user);

 

           Integer.parseInt("asdfsdfsfsd");

           Log log = new Log();

           log.setType("安全日志");

           log.setDetail("xxx进入系统");

           log.setTime(new Date());

 

           LogManager logManager = new LogManagerImpl();

           logManager.addLog(log);

 

           session.getTransaction().commit();

       }catch(Exception e) {

           e.printStackTrace();

           session.getTransaction().rollback();

//     }finally {

//         HibernateUtils.closeSession(session);

       }

    }

 

补充说明

 

采用编程式事务

 

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>      

 

十六、采用声明式事务与hibernate集成

 

1、声明式事务配置

    * 配置SessionFactory

    * 配置事务管理器

    * 事务的传播特性

    * 那些类那些方法使用事务

 

2、编写业务逻辑方法

    * 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是

      Hibernate Session的轻量级封装

    * 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的

    * 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理

    * 关于事务边界的设置，通常设置到业务层，不要添加到Dao上 

 

注意在配置文件

 

对调用hibernateDaoSupport的类配置时要加入下面：必须显示注入sessionfactroy

 

<bean id="userManager" class="com.bjsxt.usermgr.manager.UserManagerImpl">

       <property name="sessionFactory" ref="sessionFactory"/>

       <property name="logManager" ref="logManager"/>

    </bean>

   

    <bean id="logManager" class="com.bjsxt.usermgr.manager.LogManagerImpl">

       <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

 

 

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 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。

         除了防止脏读，不可重复读外，还避免了幻像读。

 

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: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 注入到hibernate中-->

    <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.*.*(..))"/>

       <!-- advisor由pointcut和advice组成 -->

       <aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>

    </aop:config>

</beans>

 

客户端调用

 

    User user = new User();

       user.setName("张三");

      

       BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext-*.xml");

       UserManager userManager = (UserManager)factory.getBean("userManager");

       try {

           userManager.addUser(user);

       } catch (Exception e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }

    }

注意当这个地方写错时现实插入语句那时因为spring的事务隔离级别，未提交读的原因

注意默认情况下只有运行期异常才回滚，但可以配置

 

十七、spring和struts的集成

Linsener初始化的时间早些，而servlet比较完

为了一次性读取struts文件的内容，要在web.xml文件中配置如下：

<!-- 

  <context-param>

    <param-name>contextConfigLocation</param-name>

      <param-value>classpath*:applicationContext-*.xml,/WEB-INF/applicationContext-*.xml</param-value>

  </context-param>

 -->在src下的配置

   <context-param>

    <param-name>contextConfigLocation</param-name>

    <param-value>classpath*:applicationContext-*.xml</param-value>

  </context-param>

  <!-- listenner负责读取application文件的内容放到context里面 -->

    <listener>

    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>

 

Action中的使用：依赖查找的方法第一中集成方案

BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext());

       //或使用下面的方法

       //ApplicationContext pc = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext());

       UserManager userManager = (UserManager)factory.getBean("userManager");

       userManager.login(laf.getUsername(), laf.getPassword());

 

 

 

spring+struts的集成(第二种集成方案)

原理：将业务逻辑对象通过spring注入到Action中，从而避免了在Action类中的直接代码查询

在ioc容器中配置action的控制类

<!-- name要和action中的path一样，才能控制action scope="prototype"多实例，默认是单实例 -->

 

    <bean name="/login" class="com.bjsxt.usermgr.actions.LoginAction" scope="prototype">

       <property name="userManager" ref="userManager"/>

    </bean>

 

然后配置spring在ioc容器中的代理类在action配置文件中

 

<action path="/login"

       type="org.springframework.web.struts.DelegatingActionProxy"

              name="loginForm"

              scope="request"  

       >

           <forward name="success" path="/success.jsp"/>

       </action>

 

Action中调用

 

private UserManager userManager;

   

    @Override

    public ActionForward execute(ActionMapping mapping, ActionForm form,

           HttpServletRequest request, HttpServletResponse response)

           throws Exception {

       LoginActionForm laf = (LoginActionForm)form;