Spring reference I. Giới thiệu

import org.springframework.aop.AfterReturningAdvice;

import org.springframework.aop.framework.ProxyFactory;
public class SimpleAfterAdvice implements AfterReturningAdvice {
public static void main(String[] args) {

ProxyFactory pf = new ProxyFactory();

pf.setTarget(new MessageWriter());

pf.addAdvice(new SimpleAfterAdvice());

MessageWriter proxy = (MessageWriter) pf.getProxy();

proxy.writeMessage();

}

public void afterReturning(Object returnValue, Method method,

System.out.println("");

System.out.println("After method: " + method.getName());

}
}
Ví dụ này thì không khác lớp SimpleBeforeAdvice mấy. Nhưng có một số ghi chú sau: phương thức afterReturning() của giao tiếp AfterReturningAdvice được chuyển vào các tham số gồm: giá trị trả về của method invocation, một tham chiếu đến method invocation, các tham số được chuyển cho phương thức và target của invocation. Chạy ví dụ này sẽ kết xuất như sau:

for (int i = 0; i < noOfTimes; i++) {

work();

}

}

System.out.print("");

}

}
Đây là một lớp đơn giản. Phương thức doSomeWork() chấp nhận một tham số - noOfTimes, và gọi phương thức work() một noOfTimes lần. Phương thức work chỉ đơn giản gọi sysout và chuyển vào một chuỗi rỗng.

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

import org.springframework.util.StopWatch;

StopWatch sw = new StopWatch();

sw.start(invocation.getMethod().getName());

Object returnValue = invocation.proceed();

sw.stop();
Object target = invocation.getThis();

Method method = invocation.getMethod();

System.out.println("Executed method: " + method.getName());

System.out.println("On object of type: " + target.getClass().getName());

System.out.println("Took: " + sw.getTotalTimeMillis() + " ms");

return returnValue;

}

}
Trong phương thức invoke(), chúng ta sẽ tạo một thể hiện của StopWatch và sau đó start ngay lập tức, cho phép method invocation thực thi với một lời gọi là MethodInvocation.proceed(). Ngay khi method invocation thực thi hoàn tất và trả về giá trị, chúng ta sẽ stop StopWatch và in ra số milisecond nhận được.

public static void main(String[] args) {

ProxyFactory pf = new ProxyFactory();

pf.setTarget(new WorkerBean());

pf.addAdvice(new ProfilingInterceptor());

WorkerBean proxy = (WorkerBean) pf.getProxy();

proxy.doSomeWork(100000);

}

}

ClassFilter getClassFilter ();

MethodMatcher getMethodMatcher();

}
Giao diện Pointcut định nghĩa hai phương thức, getClassFilter() và getMethodMatcher() trả về thể hiện của ClassFilter và MethodMatcher. Khi tạo pointcut riêng, bạn phải cài đặt cả hai giao tiếp ClassFilter và MethodMatcher.

System.out.println("foo");

}

public void bar(){

}

}

import org.springframework.aop.ClassFilter;

import org.springframework.aop.support.StaticMethodMatcherPointcut;
public class SimpleStaticPointcut extends StaticMethodMatcherPointcut {
public boolean matches(Method method, Class cls) {

return ("foo".equals(method.getName()));

}
public ClassFilter getClassFilter() {

return new ClassFilter() {

public boolean matches(Class cls) {

return (cls == BeanOne.class);

}

};
}

import org.aopalliance.intercept.MethodInvocation;

System.out.println("Excuted Method: " + invocation.getMethod().getName());

Object relValue = invocation.proceed();

System.out.println(">> Done");

return relValue;

}
}
Bây giờ chúng ta viết một ứng dụng đơn giản để tạo một thể hiện của DefaultPointcutAdvisor sử dụng các lớp SimpleAdvice và SimpleStaticPointcut.

import org.springframework.aop.Pointcut;

import org.springframework.aop.framework.ProxyFactory;

import org.springframework.aop.support.DefaultPointcutAdvisor;

public static void main(String[] args) {

BeanOne one = new BeanOne();

BeanTwo two = new BeanTwo();

Pointcut pc = new SimpleStaticPointcut();

Advice advice = new SimpleAdvice();

DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();

advisor.setAdvice(advice);

advisor.setPointcut(pc);

ProxyFactory pf = new ProxyFactory();

pf.setTarget(one);

pf.addAdvisor(advisor);

BeanOne proxyOne = (BeanOne) pf.getProxy();

pf = new ProxyFactory();

pf.setTarget(two);

pf.addAdvisor(advisor);

BeanTwo proxyTwo = (BeanTwo) pf.getProxy();

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

proxyOne.foo();

proxyTwo.foo();

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

proxyOne.bar();

proxyTwo.bar();

}

}

public void foo(int x) {

System.out.println("Invoked foo() with: " + x);

}

public void bar(){

}

}

import org.springframework.aop.ClassFilter;

import org.springframework.aop.support.DynamicMethodMatcherPointcut;
public class SimpleDynamicPointcut extends DynamicMethodMatcherPointcut {
public boolean matches(Method method, Class cls, Object[] args) {

System.out.println("Dynamic check for: " + method.getName());

int x = ((Integer)args[0]).intValue();

return (x != 100);

}

public boolean matches(Method method, Class cls){

return ("foo".equals(method.getName()));

}

public ClassFilter getClassFilter() {

public boolean matches(Class cls) {

return (cls == SampleBean.class);

}

};

}
Như đoạn code ở trên, chúng ta override lên phương thức getClassFilter() trong ngữ cảnh tương tự như ví dụ trước. Mặc dù chỉ yêu cầu cài đặt dynamic check, nhưng ở đây chúng ta cài đặt cả static check vì chúng ta biết phương thức bar() sẽ không bao giờ được advise. Và chúng ta thể hiện điều này bằng cách sử dụng static check, Spring tạo ra nó để không phải thực thi dynamic check cho phương thức này. Nếu chúng ta bỏ qua static check, Spring sẽ thực hiện dynamic check mỗi khi phương tức bar() được triệu gọi thậm chí nó luôn luôn trả về false. Trong phương thức matches(Method, Class, Object[]), bạn có thể thấy rằng chúng trả về false nếu giá trị của tham số được đến phương thức foo() là 100, ngược lại chúng ta sẽ trả về true. Chú ý trong dynamic check, chúng ta biết rằng chúng ta đang giải quyết phương thức foo() và các phương thức khác sẽ được chuyển đến static check.

import org.springframework.aop.framework.ProxyFactory;

import org.springframework.aop.support.DefaultPointcutAdvisor;
public class DynamicPointcutExample {
/**

* @param args

*/

public static void main(String[] args) {

Advisor advisor = new DefaultPointcutAdvisor(

new SimpleDynamicPointcut(), new SimpleAdvice());

ProxyFactory pf = new ProxyFactory();

pf.setTarget(bean);

pf.addAdvisor(advisor);

SampleBean proxy = (SampleBean) pf.getProxy();

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

proxy.foo(1);

proxy.foo(10);

proxy.foo(100);

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

proxy.bar();

proxy.bar();

}
}
Chúng ta sử dụng lớp advice trong ví dụ static pointcut. Tuy nhiên, trong ví dụ này, chỉ hai lời gọi đầu nên được advise. Dynamic check ngăn chặn lời gọi thứ ba của phương thức foo() khỏi advise và static check cũng ngăn phương thức bar() khỏi advice. Chạy ví dụ này sẽ kết xuất như sau:
2007/01/20 10:58:30 org.springframework.aop.framework.DefaultAopProxyFactory

情報: CGLIB2 available: proxyTargetClass feature enabled

2007/01/20 10:58:31 org.springframework.core.CollectionFactory

情報: JDK 1.4+ collections available

Static check for: foo

Static check for: bar

Static check for: hashCode

Static check for: clone

Static check for: toString

-----Foo------

Static check for: foo

Dynamic check for: foo

Excuted Method: foo

Invoked foo() with: 1

>> Done

Dynamic check for: foo

Excuted Method: foo

Invoked foo() with: 10

>> Done

Dynamic check for: foo

Invoked foo() with: 100

-----Bar------

Static check for: bar

Invoked bar()

Invoked bar()
Mặc dù dynamic pointcut thì uyển chuyển hơn static pointcut nhưng nó tốn nhiều phí runtime khi yêu cầu nó, vì thế bạn chỉ nên sử dụng dynamic pointcut khi thật sự cần thiết.
Sử dụng Name Matching:
Thường khi tạo một pointcut, bạn muốn phù hợp dựa vào tên của phương thức, bỏ qua loại trả về cùng các tham số. Trong trường hợp này, bạn có thể thực hiện bằng cách tạo một lớp con của StaticMethodMatcherPointcut và sử dụng NameMatchMethodPointcut. Khi sử dụng NameMatchMethodPointcut, nó sẽ bỏ qua signature của phương thức (tên, tham số, giá trị trả về) vì thế nếu bạn có hai phương thức foo() và foo(int) thì cả hai đều phù hợp với tên foo.
public class NameBean {
public void foo(){

System.out.println("foo");

}

public void foo(int x){

}

public void bar() {

}

public void yup(){

}

}

import org.springframework.aop.Pointcut;

import org.springframework.aop.framework.ProxyFactory;

import org.springframework.aop.support.DefaultPointcutAdvisor;

import org.springframework.aop.support.NameMatchMethodPointcut;
public class NamePointcutExample {
/**

* @param args

*/

public static void main(String[] args) {

NameMatchMethodPointcut pc = new NameMatchMethodPointcut();

pc.addMethodName("foo");

pc.addMethodName("bar");

Advisor advisor = new DefaultPointcutAdvisor(pc, new SimpleAdvice());

// create proxy

ProxyFactory pf = new ProxyFactory();

pf.setTarget(bean);

pf.addAdvisor(advisor);

NameBean proxy = (NameBean) pf.getProxy();

proxy.foo();

proxy.foo(100);

proxy.bar();

proxy.yup();

}
}
Không cần phải tạo một lớp cho pointcut, bạn có thể đơn giản tạo một thể hiện của NameMatchMethodPointcut. Chạy ví dụ này sẽ kết xuất như sau:
2007/01/20 11:23:24 org.springframework.aop.framework.DefaultAopProxyFactory

情報: CGLIB2 available: proxyTargetClass feature enabled

2007/01/20 11:23:24 org.springframework.core.CollectionFactory

情報: JDK 1.4+ collections available

Excuted Method: foo

foo

>> Done

Excuted Method: foo

foo 100

>> Done

Excuted Method: bar

bar

>> Done

yup
Tạo pointcut với Regular Expressions:
Trong các phần trước, chúng ta đã thảo luận làm thế nào để chọn ra danh sách các phương thức phù hợp. Nhưng nếu bạn không biết tên của các phương thức mà biết pattern của tên đó. Ví dụ bạn muốn chọn ra tất cả các phương thức mà tên của nó bắt đầu bằng get. Trong trường hợp này, bạn có thể sử dụng regular expression pointcut: JdkRegexpMethodPointcut hoặc Perl5RegexpMethodPointcut để chọn ra các phương thức có tên phù hợp dựa vào regular expression.
Lớp RegexpBean chứa 3 phương thức sau:
public class RegexpBean {

public void foo1(){

System.out.println("foo1");

}

public void foo2(){

}

public void bar(){

}

}

import org.springframework.aop.support.DefaultPointcutAdvisor;

import org.springframework.aop.support.JdkRegexpMethodPointcut;
public class RegexpPointcutExample {
/**

* @param args

*/

public static void main(String[] args) {

JdkRegexpMethodPointcut pc = new JdkRegexpMethodPointcut();

pc.setPattern(".*foo.*");

DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pc, new SimpleAdvice());

// create proxy

ProxyFactory pf = new ProxyFactory();

pf.setTarget(bean);

pf.addAdvisor(advisor);

RegexpBean proxy = (RegexpBean) pf.getProxy();

proxy.foo1();

proxy.foo2();

proxy.bar();

}
}
Chúng ta không cần tạo một lớp pointcut, mà thay vào đó chúng ta tạo một thể hiện của JdkRegexpMethodPointcut và xác định pattern. Một thứ thú vị ở đây là pattern, khi tên của phương thức phù hợp pattern thì Spring xem phương thức đó là phù hợp.

Chạy ví dụ này sẽ kết xuất như sau:

System.out.println("foo");

}

public void bar(){

}

}

private MyDependency dep;

public void execute(){

dep.foo();

dep.bar();

}
public MyDependency getDep() {

return dep;

}
public void setDep(MyDependency dep) {

this.dep = dep;

}

}

import org.springframework.aop.MethodBeforeAdvice;

System.out.println("Executed method: " + method.getName());

}
}
Proxy đầu tiên sẽ advise target sử dụng trực tiếp advice, do đó tất cả các phương thức sẽ được advise. Proxy thứ hai, chúng ta sẽ cấu hình JdkRegexpMethodPointcut và DefaultPointcutAdvisor vì thế chỉ phương thức foo() của lớp MyDependency được advise. Để test advice, chúng ta sẽ tạo 2 định nghĩa bean của MyBean, mỗi bean sẽ được xen với proxy khác nhau. Sau đó chúng ta sẽ triệu gọi phương thức execute() trên mỗi bean này và quan sát điều gì sẽ xảy ra khi các phương thức được advise trên dependency được triệu gọi.


DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">












































advice























advisor




























.*foo.*












Chúng ta không làm bất kỳ thứ gì đặc biệt, chúng ta đơn giản thiết lập các thuộc tính mà chúng ta thiết lập trong code sử dụng khả năng DI của Spring.

Lớp sau sẽ lấy 2 thể hiện của MyBean từ ApplicationContext và sau đó gọi phương thức execute() cho mỗi bean:

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class ProxyFactoryBeanExample {
/**

* @param args

*/

public static void main(String[] args) {

MyBean bean1 = (MyBean) context.getBean("myBean1");

MyBean bean2 = (MyBean) context.getBean("myBean2");

bean1.execute();

bean2.execute();

}
}
Chạy ví dụ này sẽ kết xuất như sau:

int getPropagationBehavior();

int getIsolationLevel();

int getTimeout();

boolean isReadOnly();

}
Một số phương thức đơn giản và rõ ràng của giao tiếp này là getTimeout(), trả về thời gian (số giây) mà transaction phải hoàn tất và isReadOnly() để chỉ giao dịch là chỉ đọc. Transaction manager có thể sử dụng giá trị này để đáng giá việc thực thi và kiểm tra giao dịch đang thực hiện có phải read-only hay không.

• 
  TransactionDefinition.ISOLATION_DEFAULT - sử dụng isolation level mặc định của datastore ở dưới.
  
• 
  TransactionDefinition.ISOLATION_READ_UNCOMMITTED - level thấp nhất của isolation, nó cho phép giao dịch xem dữ liệu được sửa bởi các giao dịch khác chưa ủy nhiệm (commit).
  
• 
  TransactionDefinition.ISOLATION_READ_COMMITTED - level mặc định trong một số database, nó đảm bảo các giao dịch không thể đọc dữ liệu chưa commit bởi giao dịch khác.
  
• 
  TransactionDefinition.ISOLATION_REPEATABLE_READ - nhiều giới hạn hơn ISOLATION_READ_COMMITTED, nó đảm bảo rằng mỗi khi bạn chọn dữ liệu, bạn có thể chọn ít nhất cùng một tập hợp như thế một lần nữa. Điều này có nghĩa là giao dịch khác chèn dữ liệu mới, bạn có thể chọn dữ liệu mới được chèn đó.
  
• 
  TransactionDefinition.ISOLATION_SERIALIZABLE - isolation level đáng tin cậy, serializable có nghĩa là giao dịch phải được thực thi hoàn tất trước khi thực thi giao dịch khác - tuần tự.
  

Chọn isolation level thì rất quan trọng để đảm bảo tính toàn vẹn của dữ liệu, nhưng các sự lựa chọn này có thể ảnh hưởng đến tốc độ. Isolation level cao nhất ISOLATION_SERIALIZABLE thì trả giá đắc nhất để bảo trì.

• 
  TransactionDefinition.PROPAGATION_REQUIRED - thực thi giao dịch hiện hành, tạo một giao dịch mới nếu như không có giao dịch tồn tại.
  
• 
  TransactionDefinition.PROPAGATION_SUPPORTS - thực thi giao dịch nếu như nó tồn tại. Nếu không có thì không thực thi.
  
• 
  TransactionDefinition.PROPAGATION_MANDATORY - thực thi giao dịch nếu như có một giao dịch tồn tại. Ném vào một ngoại lệ nếu như không có giao dịch kích hoạt.
  
• 
  TransactionDefinition.PROPAGATION_REQUIRES_NEW - luôn khởi tạo một giao dịch mới. Nếu như tồn tại một giao dịch đang hoạt động, thì nó sẽ bị tạm dừng.
  
• 
  TransactionDefinition.PROPAGATION_NOT_SUPPORTED - không thực thi giao dịch và dừng bất kỳ giao dịch nào đang tồn tại.
  
• 
  TransactionDefinition.PROPAGATION_NEVER - luôn luôn không thực thi thậm chí có giao dịch tồn tại. Ném vào ngoại lệ nếu có một giao dịch tồn tại.
  

"http://www.springframework.org/dtd/spring-beans.dtd">

"http://www.springframework.org/dtd/spring-beans.dtd">