随笔档案(496)

1packagesinosoft.dj.aop.proxyaop;
2
3importjava.lang.reflect.Method;
4
5publicinterfaceIOperation{
6  /**
7      * 方法执行之前的操作
8      *@parammethod
9     */
10    voidstart(Method method);
11  /**
12      * 方法执行之后的操作
13      *@parammethod
14     */
15    voidend(Method method);
16}
17

packagesinosoft.dj.aop.proxyaop;

importjava.lang.reflect.Method;

publicclassLoggerOperationimplementsIOperation{

    publicvoidend(Method method){
         Logger.logging(Level.DEBUGE, method.getName()+"Method end.");
     }

    publicvoidstart(Method method){
         Logger.logging(Level.INFO, method.getName()+"Method Start!");
     }

}

但是我们会发现一个问题,如果我们像Hello这样的类很多,那么,我们是不是要去写很多个HelloProxy这样的类呢.没错,是的.其实也是一种很麻烦的事.在jdk1.3以后.jdk跟我们提供了一个API   java.lang.reflect.InvocationHandler的类. 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.让我们把以上的代码改一下来看看效果.
同样,我们写一个IHello的接口和一个Hello的实现类.在接口中.我们定义两个方法;代码如下 :

IHello.java

1package sinosoft.dj.aop.proxyaop;
2
3public interface IHello {
4  /**
5      * 业务处理A方法
6      * @param name
7     */
8    void sayHello(String name);
9  /**
10      * 业务处理B方法
11      * @param name
12     */
13    void sayGoogBye(String name);
14}
15

Hello.java

1package sinosoft.dj.aop.proxyaop;
2
3public class Hello implements IHello {
4
5    public void sayHello(String name) {
6         System.out.println("Hello " + name);
7     }
8    public void sayGoogBye(String name) {
9         System.out.println(name+" GoodBye!");
10     }
11}
12

我们一样的去写一个代理类.只不过.让这个类去实现java.lang.reflect.InvocationHandler接口,代码如下:

1package sinosoft.dj.aop.proxyaop;
2
3import java.lang.reflect.InvocationHandler;
4import java.lang.reflect.Method;
5import java.lang.reflect.Proxy;
6
7public class DynaProxyHello implements InvocationHandler {
8
9   /**
10      * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
11     */
12    private Object delegate;
13
14/**
15      * 动态生成方法被处理过后的对象 (写法固定)
16      *
17      * @param delegate
18      * @param proxy
19      * @return
20     */
21    public Object bind(Object delegate) {
22        this.delegate = delegate;
23        return Proxy.newProxyInstance(
24                this.delegate.getClass().getClassLoader(), this.delegate
25                         .getClass().getInterfaces(), this);
26     }
27  /**
28      * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
29      * 此方法是动态的,不是手动调用的
30     */
31    public Object invoke(Object proxy, Method method, Object[] args)
32            throws Throwable {
33         Object result = null;
34        try {
35            //执行原来的方法之前记录日志
36             Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
37            
38            //JVM通过这条语句执行原来的方法(反射机制)
39             result = method.invoke(this.delegate, args);
40            //执行原来的方法之后记录日志
41             Logger.logging(Level.INFO, method.getName() + " Method Start!");
42         } catch (Exception e) {
43             e.printStackTrace();
44         }
45        //返回方法返回值给调用者
46        return result;
47     }
48
49}
50

上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.

让我们写一个Test类去测试一下.代码如下:
Test.java

1package sinosoft.dj.aop.proxyaop;
2
3public class Test {
4    public static void main(String[] args) {
5         IHello hello = (IHello)new DynaProxyHello().bind(new Hello());
6         hello.sayGoogBye("Double J");
7         hello.sayHello("Double J");
8        
9     }
10}
11

运行输出的结果如下:

Tue Mar 04 21:24:03 CST 2008 sayGoogBye Method end .
Double J GoodBye!
2008-3-4 21:24:03 sayGoogBye Method Start!
Tue Mar 04 21:24:03 CST 2008 sayHello Method end .
Hello Double J
2008-3-4 21:24:03 sayHello Method Start!

由于线程的关系,第二个方法的开始出现在第一个方法的结束之前.这不是我们所关注的!

1packagesinosoft.dj.aop.staticaop;
2
3publicinterfaceIHello{
4  /**
5      * 假设这是一个业务方法
6      *@paramname
7     */
8    voidsayHello(String name);
9}
10

packagesinosoft.dj.aop.staticaop;

publicclassHelloimplementsIHello{

    publicvoidsayHello(String name){
         System.out.println("Hello"+name);
     }

}

1packagesinosoft.dj.aop.staticaop;
2
3publicclassHelloProxyimplementsIHello{
4    privateIHello hello;
5
6    publicHelloProxy(IHello hello){
7        this.hello=hello;
8     }
9
10    publicvoidsayHello(String name){
11         Logger.logging(Level.DEBUGE,"sayHello method start.");
12         hello.sayHello(name);
13         Logger.logging(Level.INFO,"sayHello method end!");
14
15     }
16
17}
18

1packagesinosoft.dj.aop.staticaop;
2
3importjava.util.Date;
4
5publicclassLogger{
6  /**
7      * 根据等级记录日志
8      *@paramlevel
9      *@paramcontext
10     */
11    publicstaticvoidlogging(Level level, String context){
12        if(level.equals(Level.INFO)){
13             System.out.println(newDate().toLocaleString()+""+context);
14         }
15        if(level.equals(Level.DEBUGE)){
16             System.err.println(newDate()+""+context);
17         }
18     }
19
20}
21

1packagesinosoft.dj.aop.staticaop;
2
3publicenumLevel{
4     INFO,DEBUGE;
5}
6

1packagesinosoft.dj.aop.staticaop;
2
3publicclassTest{
4    publicstaticvoidmain(String[] args){
5         IHello hello=newHelloProxy(newHello());
6         hello.sayHello("Doublej");
7     }
8}
9

Tue Mar0420:57:12CST2008sayHello method start.
Hello Doublej
2008-3-420:57:12sayHello method end!

1packagesinosoft.dj.aop.staticaop;
2
3publicclassTest{
4    publicstaticvoidmain(String[] args){
5         IHello hello=newHello();
6         hello.sayHello("Doublej");
7     }
8}
9

<SCRIPT LANGUAGE="JavaScript">

       function selectInst(){

              var checkbox = document.getElementsByName("inst");

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

                     if(checkbox[i].checked){

                            var temp = checkbox[i].value;

                            alert(temp);

                     }

              }

       }

</SCRIPT>

<form>

       选择爱好:<br>

       <input type="checkbox" name="inst" value="足球">足球

       <input type="checkbox" name="inst" value="篮球">篮球

       <input type="checkbox" name="inst" value="音乐">音乐

       <input type="checkbox" name="inst" value="上网">上网

       <input type="checkbox" name="inst" value="跳舞">跳舞

       <input type="button" value="提交" onclick="selectInst()">

<SCRIPT LANGUAGE="JavaScript">

       var checkFlag = "false";

       function selectAll(field){

              if(checkFlag=="false"){

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

                            field[i].checked=true;

                     }

                     checkFlag = "true";

              }else{

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

                            field[i].checked=false;

                     }

                     checkFlag = "false";

              }}

</SCRIPT>

<form>

       选择爱好: <br>

       <input type="checkbox" name="inst" value="足球">足球

       <input type="checkbox" name="inst" value="篮球">篮球

       <input type="checkbox" name="inst" value="音乐">音乐

       <input type="checkbox" name="inst" value="上网">上网

       <input type="checkbox" name="inst" value="跳舞">跳舞

       <input type="checkbox" name="chkAll" value="instAll" onclick="selectAll(this.form.inst)">全选<br>

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
 <property name="beanNames"><value>jdk*,onlyJdk</value></property>
 <property name="interceptorNames">
  <list>
   <value>myInterceptor</value>
  </list>
 </property>
</bean>

需明确的几个概念:

l         通知(Advice)：用于告知系统将有哪些新的行为。

l         切入点(Pointcut):定义了通知应该在应用到那些连接点。

l         目标对象(Target)：被通知的对象。

l         代理(Proxy)：将通知应用到目标对象后创建的对象。

Spring有两种代理创建方式：

1.   如果目标对象实现了一个或多个接口暴露的方法，Spring将使用JDK的java.lang.reflect.Proxy创建代理。这个类让Spring动态产生一个新的类，它实现了所需的接口，织入了通知，并且代理目标的所有请求。（这篇主要介绍这个方式）

2.   如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。在创建这个子类的时候，Spring将通知织入，并且将对目标对象的调用委托给这个子类。

下面以一个实例说明Spring AOP的基本开发方法：

一．创建通知

Spring连接点模型是建立在方法拦截上，这意味着你编写的

Spring通知会在方法调用周围的各个地方织入系统中。

1. 全面支持java6和javaEE5（JDBC 4.0, JTA 1.1, JavaMail 1.4, JAX-WS 2.0等）
2. 全特性的注释驱动依赖注入，包括对限定词的支持
3. 支持基于classpath的组件扫描，自动侦测有注释的类
4. 支持AspectJ切点表达式中包含bean name切点元素
5. 内置AspectJ加载时编织，基于LoadTimeWeaver 提取
6. 更多的XML配置文件的名字空间支持，比如context和jms等，最大程度提高编写的方便性
7. 全面修订集成测试框架，支持JUnit4和TestNG
8. 新的基于注释的Servlet MVC和Portlet MVC控制器风格配置
9. 扩展SimpleJdbcTemplate功能，支持命名的参数等
10. 官方认可的Websphere支持，支持WebSphere 6 UOWManager 机制
11. Spring框架的jar文件，兼容OSGi绑定，并能直接使用
12. Spring ApplicationContext可被部署为JCA RAR文件，用于非主导应用模块
13. JCA 1.5消息终端管理，用于Spring管理的JMS和CCI消息监听器

一、事务管理
事务传播
1、required:方法在一个事务中执行，如果调用的方法在一个事务中，则使用该事务，否则将创建一个新的事务。(必须有，有就用，没有就建)
2、mandatory:如果运行于事务中的客户调用了该方法，方法在客户的事务中执行。如果客户没有关联到事务中，容器就会抛出TransactionRequiredException.(必须有，有就用，没有报错)
3、requiresnew:方法将在一个新的事务中执行，如果调用的方法已经在一个事务中，则暂停旧的事务。在调用结束后恢复旧的事务。(必须有，有没有都要建)
4、supports:如果方法在一个事务中被调用，则使用该事务，否则不使用事务。(有没有都中，有就用，没有不用)
5、not_supported:如果方法在一个事务中被调用，容器会在调用之前终止该事务。在调用结束后，容器会恢复客户事务。如果客户没有关联到一个事务中，容器不会入运行在该方法启动一个新的事务。用notsupported属性标识不需要事务的方法。因为事务会带来更高的性能支出，所以这个属性可以提高性能。(不需要，有就挂起事务，没有直接运行)
6、Never:如果在一个事务中调用该方法，容器会抛出RemoteException。如果客户没有关联到一个事务中，容器不会在运行入该方法前启动一个新的事务。(必须没有，有就报错，没有就直接运行)
事务隔离
为什么要使用事物隔离，是因为事物并发引起的一些错误现象
并发问题：
脏读：一个事务读取了未提交的事务
不可重复读：同一个事务中多次读取同一个数据返回的结果不同
幻读：一个事务读取到了另一个事务已提交的insert数据。

事务并发处理：
共享锁：共享锁用于读取数据操作，它允许其他事务同时读取某锁定的资源，但不允许其他事务更新它。
排他锁：排它锁用于修改数据的场合。它锁定的资源，其他事务不能读取也不能修改。
更新锁：更新锁在更新操作的初始化阶段用来锁定可能要被修改的资源，从而避免使用共享锁造成的死锁现象。

事务隔离级别：
ReadUncommitted：读未提交数据,该选项指示数据库读取数据时不使用任何锁。在这种情况下，事务可以读取到未提交的数据，会出现脏读，不可重复读和幻读现象。

ReadCommited：
该选项只会返回"读取时间点"之前已提交的数据。因此可以避免脏读，但是会出现不可重复读，另外还会出现幻读现象。

RepeatableRead:该选项能够保证可重复读，可以避免脏读和不可重复读。

Serializable:该选项能够避免脏读、不可重复读和幻读现象，是最严格的隔离级别。

二、spring集成struts
1、应用服务器没有直接调用启动Spring的方法，但是应用服务器编译运行servlet，filter,listener，所以spring提供一个listener类，在服务器初始化的时候调用该类中的方法，所以在容器中配置如下：
<!-- 指定spring的配置文件,多个文件之间用逗号分隔 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 启动Spring容器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
2、我们把我们需要交给spring管理的类在beans.xml中配置：
如<bean name="/user/regist"
class="cn.sun.ssh.web.action.UserManagerAction">
<property name="dao" ref="userDAO"></property>
</bean>
但是action是被引擎调用的，我们如何把需要的action交给引擎呢，通过重写struts中的requestprocessor类中的processactioncreate方法，在spring中获得action后交给引擎管理，这也是struts的一个扩展机制。
所以我们要在struts-config.xml中配置controller
<controller>
<set-property property="processorClass" value="org.springframework.web.struts.DelegatingRequestProcessor"/>
</controller>


三、spring集成hibernate
1、spring集成hibernate时把dao和sessionfactory交给spring管理