spring基础学习四（aop）
这里先占个位置，今天晚上下班后完成！
痛苦啊！我们被困在办公室里了！一开门就走吧。只是可惜今天没有写这篇文章了!唉，计划不如变化快啊！
还没写这篇文章呢？就要催着走！
今天补上这一篇的内容：
目录：
1、AOP的原理
2、AOP的使用
1、AOP原理：
AOP编程是面向对象思维方式的有力补充。
面向切面编程就是在要运行的代码 前、后 加一些信息代码,而不影响原来的代码。
如果在框架中，没有AOP的这部分框架，我们自己也可以是实现面向切面编程----有两种比较好的方式：继承方式和组合设计模式
package com.longkun.aop.test;
public class Algorithm {
/**
* @author longkun.wyb
* 求一组数据的逆序数，归并排序
* @param args
*/
static int num = 0;
public void main(){
System.out.println(2.00-1.10);
System.out.printf("%.2f\n",2.00-1.10);
int value[] = {0,10,100,45,39};
int left = 0;
int right = value.length-1;
mergeSort(value,left,right);
System.out.println(num);
for(int i = 0 ; i <= right; ++i){
System.out.print(" "+value[i]);
}
}
private void mergeSort(int[] value,int left,int right){
if(left<right){
int middle = (left+right)/2;
mergeSort(value,left,middle);
mergeSort(value,middle+1,right);
merge(value,left,middle,right);
}
}
private void merge(int[] value,int left,int middle,int right){
int[] tmp = new int[100];
int k = left;
int i = left;
int j = middle+1;
for(; i <= middle && j<= right ;){
if(value[i] > value[j]){
num+=middle-i+1;
tmp[k++]=value[j++];
}else{
tmp[k++]=value[i++];
}
}
while(i<=middle){
tmp[k++]=value[i++];
}
while(j<=right){
tmp[k++]=value[j++];
}
for(i=left;i<=right;++i){
value[i]=tmp[i];
}
}
}
在这段代码前后加代码的话，可以继承这个类，调用super的方式：
package com.longkun.aop.test;
public class AlgorithmLog extends Algorithm{
@Override
public void main() {
System.out.println("log... start ...");
super.main();
System.out.println("log... end ...");
}
}
但是如过想在这段代码前后在加内容就要再继承它：
package com.longkun.aop.test;
public class AlgorithmRuntime extends AlgorithmLog{
@Override
public void main() {
System.out.println("Run start ...");
long start = System.currentTimeMillis();
super.main();
long end = System.currentTimeMillis();
System.out.println("Run end..."+" 时间："+(end-start));
}
}
问题来了，你如过想让RunTime在前，Log再后，那改代码就很麻烦了。需要让Algorithm继承AlgorithmRuntime等一系列。
于是我们使用一种设计模式，聚合设计模式----这种方法只是客户使用端的排列使用，相对简单了许多
首先建一个接口AlgorithmInterface,都去实现它。
看代码：
package com.longkun.aop.test;
public interface AlgorithmInterface {
public void main();
}
一个主要的实现类，核心代码：
package com.longkun.aop.test;
public class Algorithm implements AlgorithmInterface{
public void main(){
System.out.println("求一组数据的逆序数，归并排序");
}
} 一些切面上的代码：
log
package com.longkun.aop.test;
public class AlgorithmLog implements AlgorithmInterface{
AlgorithmInterface al = null;
public AlgorithmLog(AlgorithmInterface algorithm){
this.al = algorithm;
}
@Override
public void main() {
System.out.println("log... start ...");
al.main();
System.out.println("log... end ...");
}
}
runtime:
package com.longkun.aop.test;
public class AlgorithmRuntime implements AlgorithmInterface{
AlgorithmInterface al = null;
public AlgorithmRuntime(AlgorithmInterface algorithm) {
this.al = algorithm;
}
@Override
public void main() {
System.out.println("Run start ...");
long start = System.currentTimeMillis();
al.main();
long end = System.currentTimeMillis();
System.out.println("Run end..."+" 时间："+(end-start));
}
}
客户应用的调用：package com.longkun.aop.test;
package com.longkun.aop.test;
public class Client {
public static void main(String[] args){
AlgorithmInterface al = new Algorithm();
AlgorithmInterface log = new AlgorithmLog(al);
AlgorithmInterface runtime = new AlgorithmRuntime(log);
runtime.main();
System.out.println("************************************************");
AlgorithmInterface runtime1 = new AlgorithmRuntime(al);
AlgorithmInterface log1 = new AlgorithmLog(runtime1);
log1.main();
}
}
执行结果：
Run start ...
log... start ...
求一组数据的逆序数，归并排序
log... end ...
Run end... 时间：0
************************************************
log... start ...
Run start ...
求一组数据的逆序数，归并排序
Run end... 时间：0
log... end ...
这就是聚合设计模式的思想，重要的是要记住其中的组织结构。
在spring中的AOP的实现工程呢，则是使用动态代理的方式，比聚合设计模式还要简单一些，实现过程没有去模仿。在这里就说明一下使用。
2、AOP的使用
AOP的使用，分为注解注入方式（@AspectJ）和配置文件注入方式，由于AOP的注解方式很少用，并有一些不方便，所以这里讲解一下xml配置文件的注入使用方式。
几个简单的概念：
切面（Aspect）是现实世界领域问题的抽象，除了包括属性、方法以外，同时切面中还包括切入点 Pointcut、增强（advice）等。
连接点（Join point）：连接点也就是运用程序执行过程中需要插入切面模块的某一点
切入点（Pointcut）：切入点指一个或多个连接点，可以理解成一个点的集合。切入点一般会跟连接点的上下文环境结合
增强或通知（Advice）：定义了切面中的实际逻辑（即实现），是指在定义好的切入点处，所要执行的程序代码。
一个样例：
beans.xml
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-2.5xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />
<bean id="algorithm" class="com.longkun.aop.test.Algorithm"></bean>
<bean id="algorithmLog" class="com.longkun.aop.test.AlgorithmLog"/>
<aop:config>
<aop:aspect ref="algorithmLog">
<aop:before method="beforeMain" pointcut="execution(public * com.longkun.aop.test..*.*(..))"/>
<!-- 第一个*代表任何返回类型，第二个*代表com.longkun.aop.test包以及子包的任何类，第三个*代码任何方法 -->
<aop:after-returning method="afterReturnMain" pointcut="execution(public * com.longkun.aop.test.Algorithm.main(..))" returning="reval"/>
<aop:after method="afterMain" pointcut="execution(public void com.longkun.aop.test..*.main(..))"/>
<aop:after-throwing method="afterThrowingMain" pointcut="execution(public * com.longkun.aop.test.Algorithm.main(..))" throwing="ex"/>
<aop:around method="aroundMain" pointcut="execution(public * com.longkun.aop.test..*.display(..))"/>
</aop:aspect>
</aop:config>
</beans> 使用到动态的代理一定要用接口：
package com.longkun.aop.test;
public interface AlgorithmInterface {
public void main();
public void display();
}
实现接口：
package com.longkun.aop.test;
public class Algorithm implements AlgorithmInterface{
public void display() {
System.out.println("display......。。。。。。");
}
public void main(){
System.out.println("求一组数据的逆序数，归并排序。。。。。。。");
}
}
实现切面的类代码：
package com.longkun.aop.test;
import org.aspectj.lang.ProceedingJoinPoint;
public class AlgorithmLog{
public AlgorithmLog(){}
public void beforeMain(){
System.out.println("beforeMain ... beforeMain");
}
public void afterMain(){
System.out.println("afterMain ... afterMain:");
}
public void afterReturnMain(String reval){
System.out.println("afterReturnMain ... afterReturnMain:"+reval);
}
public void afterThrowingMain(Exception ex){
System.out.println("afterThrowingMain:"+ex.getMessage());
}
public void aroundMain(ProceedingJoinPoint joinPoint){
System.out.println("Aruound Before..");
try {
joinPoint.proceed();
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("Around After!!");
}
}
应用客户端实现：
package com.nullf;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.longkun.aop.test.AlgorithmInterface;
public class Client {
public static void main(String[] args){
ApplicationContext acx = new ClassPathXmlApplicationContext("beans.xml");
AlgorithmInterface al = (AlgorithmInterface)acx.getBean("algorithm");
System.out.println("hello main");
al.main();
// al.display();
}
}
打印结果：
hello main beforeMain ... beforeMain beforeMain ... beforeMain 求一组数据的逆序数，归并排序。。。。。。。 afterReturnMain ... afterReturnMain:null afterMain ... afterMain: afterMain ... afterMain:
beforeMain ... beforeMain
afterMain ... afterMain:
这两句话出现两次，是因为com.longkun.aop.test包及子包下，有多个方法。
<aop:before method="beforeMain" pointcut="execution(public * com.longkun.aop.test..*.*(..))"/>
将这句话改为：
<aop:before method="beforeMain" pointcut="execution(public * com.longkun.aop.test.Algorithm.*(..))"/>
beforeMain ... beforeMain 这句话就会只出现一次