NOVOTS KMS 词汇表 Glossary    联系我们 Contact Us
查询 Search  
   
按类别浏览 Browse by Category
NOVOTS KMS .: JAVA应用服务器 .: java

java

java动态代理学习笔记

涉及反射和动态代理。


在学习之前,先提出几个问题,带着问题来看代码:

1.
什么是动态代理?
2.
为什么使用动态代理?
3.
使用它有哪些好处?
4.
哪些地方需要动态代理?

--------------------
分隔线-----------------------------

和动态代理有关的有两个类
1.interface InvocationHandler
Object invoke(Object proxy, Method method, Object[] args)
只这一个方法,后面再说

2.class Proxy
真正表示动态代理的类,提供两个静态方法:

Class<?> getProxyClass(ClassLoader loader, Class<?>[] interface)
用来产生代理类,参数要提供interface数组,它会生成这些interface虚拟实现
用来冒充真实的对象。

Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
产生代理对象,多了InvocationHandler参数(只是InvocationHandler接口的实现类)
它与代理对象关联,当请求分发到代理对象后,会自动执行h.invoke(...)方法,
invoke
方法就是我们用来做N多事情的地方 -_-

--------------------
分隔线-----------------------------

看完上面的代码,大致明白动态代理的含义:
A
接口有c方法,类B实现A接口,原本应该是执行B类中的c方法,可现在不这样做;
我声明产生B类的代理类B',由它来冒充B类的兄弟实现”A接口,
对外界来说B'应该也有c方法,可当真正调用它的时候,
它会去执行与它关联InvocationHandlerinvoke()方法,
在这个方法里面你可以做很多事情。这样,这个请求就被代理到其它地方去了。

下面是根据我的理解画的一个说明图



--------------------
分隔线-----------------------------

引用网上的一个例子来说明问题(有部分改动,转载自:http://callan.iteye.com/blog/161806)
真实的接口:

Java代码  

  1. public interface Hello {

  2.  

  3.  void sayHello(String to);

  4.  

  5.  void print(String p);

  6.  

  7. }  


它的真实实现类:

Java代码  

  1. public class HelloImpl implements Hello {

  2.  

  3.  public void sayHello(String to) { 

  4.  System.out.println("Say hello to " + to);

  5.  }

  6.  

  7.  public void print(String s) {

  8.  System.out.println("print " + s);

  9.  }

  10.  

  11. }


在这里生成与代理类相关联的InvocationHandler对象

Java代码  

  1. public class LogHandler implements InvocationHandler {

  2.  

  3.  private Object dele;

  4.  

  5.  public LogHandler(Object obj) {

  6.  this.dele=obj; }

  7. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

  8.  doBefore();

  9.  //在这里完全可以把下面这句注释掉,而做一些其它的事情  

  10.  Object result = method.invoke(dele, args);

  11.  after();

  12.  return result;

  13.  }

  14.  

  15.  private void doBefore() {

  16.  System.out.println("before....");

  17.  }

  18.  

  19.  private void after() {

  20.  System.out.println("after....");

  21.  }

  22. }


最后是测试类:

Java代码  

  1. public class ProxyTest {

  2.  

  3.  public static void main(String[] args) {

  4.  HelloImpl impl = new HelloImpl();

  5.  LogHandler handler = new LogHandler(impl);

  6.  //这里把handlerimpl新生成的代理类相关联  

  7.  Hello hello = (Hello) Proxy.newProxyInstance(impl.getClass().getClassLoader(), impl.getClass().getInterfaces(), handler);

  8.  

  9.  //这里无论访问哪个方法,都是会把请求转发到handler.invoke

  10.  hello.print("All the test");

  11.  hello.sayHello("Denny");

  12.  }

  13.  

  14. }


这里是输出结果:

Java代码  

  1. before...

  2. print : All the test

  3. after....

  4. before....

  5. Say hello to Denny

  6. after....


--------------------
分隔线-----------------------------

最后试着来回答之前提出的问题:
1.
什么是动态代理?
一种用于转发请求,进行特殊处理的机制,动态应该指的是运行期
2.
为什么使用动态代理?
可以对请求进行任何处理(如事务,日志等,这都是网上说的,我当然可以做任何处理)
3.
使用它有哪些好处?
如上
4.
哪些地方需要动态代理?
不允许直接访问某些类;对访问要做特殊处理等,我只能想到这些。

--------------------
分隔线-----------------------------

其它一些想法:

1.
如果想声明产生B类的代理类,那个B类必须要实现接口,如果没有接口,
代理类就不能伪装成B类的兄弟,也就没有存在的意思,
其实也可以伪装成B类的孩子,对外他们有共同的接口,可以这样做吧?

2.
当请求代理类的方法时,这个请求会被转到执行与代理类关联InvocationHandler
invoke方法。那InvocationHandler到底是什么?对它的理解可以是这样:
它用来处理方法的调用,实现类也有同样的意义;与代理类对象相关联则表示,
它就是负责处理代理类应该有的动作,把所有的方法请求分发到invoke这个方法上。



--------------------
分隔线-----------------------------
学习后总结,既可以全面地观察分析,又能加深印象。
如果我的理解有误,别人的指证会对我产生积极影响。
如果我的理解正确,帮助其它人理解是我的荣幸。
初学者,请多多指教。

 

 

shi

 

数据库提供了四种事务隔离级别

 

 不同的隔离级别采用不同的锁类开来实现.

在四种隔离级别中, Serializable的级别最高, Read Uncommited级别最低.

大多数数据库的默认隔离级别为: Read Commited,Sql Server , Oracle.

少数数据库默认的隔离级别为Repeatable Read, MySQL InnoDB存储引擎

即使是最低的级别,也不会出现 第一类 丢失 更新问题 .

1.
脏读(事务没提交,提前读取):脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这个数据。

2.
不可重复读(两次读的不一致) :是指在一个事务内,多次读同一数据。在这个事务还没有结束时,另外一个事务也访问该同一数据。那么,在第一个事务中的两次读数据之间,由于第二个事务的 修改,那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的,因此称为是不可重复读。例如,一个编辑人员两次读取同一文档,但在两次读取之间,作者重写了该文档。当编辑人员第二次读取文档时,文档已更改。原始读取不可重复。如果只有在作者全部完成编写后编辑人员才可以读取文档,则可以避免该问题。 
3. 
幻读 : 是指当事务不是独立执行时发生的一种现象,例如第一个事务对一个表中的数据进行了修改,这种修改涉及到表中的全部数据行。同时,第二个事务也修改这个表中 的数据,这种修改是向表中插入一行新数据。那么,以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行,就好象发生了幻觉一样。例如,一个编辑人员更改作者提交的文档,但当生产部门将其更改内容合并到该文档的主复本时,发现作者已将未编辑的新材料添加到该文档中。如果在编辑人员和生产部门完成对原始文档的处理之前,任何人都不能将新材料添加到文档中,则可以避免该问题。 
4.
第一类更新丢失(回滚丢失)
2个事务更新相同的数据源,如果第一个事务被提交,而另外一个事务却被撤销,那么会连同第一个事务所做的跟新也被撤销。也就是说第一个事务做的跟新丢失了。
5.
第二类更新丢失(覆盖丢失)
二类更新丢失实在实际应用中经常遇到的并发问题,他和不可重复读本质上是同一类并发问题,通常他被看做不可重复读的特例:当2个或这个多个事务查询同样的 记录然后各自基于最初的查询结果更新该行时,会造成第二类丢失更新。因为每个事务都不知道不知道其他事务的存在,最后一个事务对记录做的修改将覆盖其他事 务对该记录做的已提交的跟新...
补充 : 基于元数据的 Spring 声明性事务 :

Isolation
属性一共支持五种事务设置,具体介绍如下:

l DEFAULT
使用数据库设置的隔离级别 ( 默认 ) ,由 DBA 默认的设置来决定隔离级别 .

l READ_UNCOMMITTED
会出现脏读、不可重复读、幻读 ( 隔离级别最低,并发性能高 )

l READ_COMMITTED
会出现不可重复读、幻读问题(锁定正在读取的行

l REPEATABLE_READ
会出幻读(锁定所读取的所有行

l SERIALIZABLE
保证所有的情况不会发生(锁表

不可重复读的重点是修改 :
同样的条件 , 你读取过的数据 , 再次读取出来发现值不一样了
幻读的重点在于新增或者删除
同样的条件 , 1 次和第 2 次读出来的记录数不一样


这篇文章对你多有用?

相关文章

article How do I uninstall all Java on my Windows computer ?
How do I uninstall Java on my Windows computer...

(No rating)  4-26-2010    Views: 1927   
article 40个大型企业Java集合面试问题和答案
...

(No rating)  12-22-2016    Views: 642   
article Java 7新功能介绍及与Java1.7性能测试比较
Java 7新功能介绍及与Java1.7性能测试比较这

(No rating)  8-6-2011    Views: 1760   

用户评语

添加评语
当前还没有评语.


.: .: .: .: .:
[ 登陆 ]
北京护航科技有限公司 2006

Novots Technologies Limited