http://www.hongyanliren.com/2014m12/22797.html

1: 通知(advice):
就是你想要的功能,也就是安全、事物、日子等。先定义好,在想用的地方用一下。包含Aspect的一段代码
2: 连接点(joinPoint):
spring允许你通知的地方,很多,基本每个方法的前、后,或抛出异常时都可以是连接点。
spring 只支持方法连接点。 其它如AspectJ还可以让你在构造器或属性注入时都行。
3: 切入点(pointcut):
一个类,15个方法,就是15个连接点,但是你不想在所有的方法都用通知,只是让其中几个,在调用这个方法之前,之后
或者抛出异常的时候干点什么,那么就用切入点来定义这几个方法,让切入点选择连接点,选中那几个你想要的方法。
4: 切面(Aspect)
切面是通知advice和切入点的结合,连接点只是为了让理解切点搞出来的,通知说明了干什么和什么时候干(before,afer等
定义了通知干活的时间)切入点说明了在哪干(就是指明方法)
5: 引入(introduction)
允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗。
可以无需修改现有的类的情况下,让他们有新的行为和状态。
6: 目标(target)
引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被织入切面。自己
只是关注业务本身逻辑。
7:代理(proxy): 由AOP生成的java对象。
8: 织入(weaving):把切面应用到目标对象来创建新的代理对象的过程。有3种方式。
编译期: 切面在目标类编译期被织入,这种方式需要特殊的编译器,如AspectJ.
类加载期: 切面在目标类加载到JVM时被织入,这种方式要特殊的类加载器。
运行期: Spring AOP用的这种方式。
9: 横切关注点: log\安全检查等。

AOP原理:
spring 用代理类包裹切面,把他们织入到spring管理的bean中,也就是说代理类伪装成目标类,它会截取对目标类中方法
的调用,调用者对目标类对调用都先变成伪装类,伪装类先执行切面,再把调用转给真正目标bean。

如何搞出个伪装类,才不会被调用者发现,如下两种方法:
1) 实现和目标类相同的接口:
我也实现和你一样的接口,反正上层都是接口级别的调用,逃过了类型检查,到java运行期的时候,利用多态的后期绑定(所以spring
采用运行时),伪装类(代理类)就变成了接口的真正实现,他里面包裹了真实的目标类,最后实现具体功能的还是目标类,伪装类干了点
额外的事情(写日志、安全检查、事物等)。

这种模式,spring用JDK的java.lang.reflect.Proxy类,它允许Spring动态生成一个新类来实现必要的接口,织入通知,并且把
这些接口的任何调用都转发到目标类。

2) 生成子类调用
用子类做伪装,逃过类型检查,重写的方法实现了目标类的功能,还在这些功能之前,实现了一些其它的(写日志,安全检查,事物)

spring使用CGLIB库生成目标类的一个子类,在创建这个子类的时候,spring织入通知。

前一种模式更好,松耦合,尤其在今天高喊着面向接口编程的情况下。

面向切面编程,在我们的应用中,经常需要做一些事情,但是这些事情与核心业务无关,比如,要记录所有update*方法的执行时间时间,操作人等等信息,记录到日志,

通过spring的AOP技术,就可以在不修改update*的代码的情况下完成该需求。

AOP实现原理-----代理

////////////////////////////////////////////////////////////////////////////////////
1: Spring通知几种类型?
org.aopalliance.intercept.MethodInterceptor
org.springframework.aop.MethodBeforeAdvice
org.springframework.aop.AfterReturningAdvice
org.springframework.aop.ThrowsAdvice
2. 谈谈目标对象实现接口与目标对象不实现接口有什么区别?
其中动态代理又可分为:
1.JDK动态代理
此时代理对象和目标对象实现了相同的接口,目标对象作为代理对象的一个属性,具体接口实现中,可以在调用目标对象相应方法前后加上其他业务处理逻辑。
代理模式在实际使用时需要指定具体的目标对象,如果为每个类都添加一个代理类的话,会导致类很多,同时如果不知道具体类的话,怎样实现代理模式呢?这就引出动态代理。
JDK动态代理只能针对实现了接口的类生成代理。
2.CGLIB代理
CGLIB(CODE GENERLIZE LIBRARY)代理是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的所有方法,所以该类或方法不能声明称final的。

3. 请描述JDK动态代理和CGLI代理的区别?
4:简述ProxyFactoryBean的作用是什么?
使用Spring提供的类org.springframework.aop.framework.ProxyFactoryBean是创建AOP的最基本的方式 .

第一种方式: 使用ProxyFactoryBean代理目标类的所有方法
<bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<!--这里代理的是接口-->
<property name="proxyInterfaces">
<value>com.gc.impl.TimeBookInterface</value>
</property>

<!--是ProxyFactoryBean要代理的目标类-->
<property name="target">
<ref bean="timeBook"/>
</property>

<!--程序中的Advice-->
<property name="interceptorNames">
<list>
<value>log</value> // 这里的log可以是5中通知中的一种。
</list>
</property>
</bean>
</beans>

第二种方式: 使用ProxyFactoryBean代理目标类的指定方法:
<bean id="logAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref bean="log"/>
</property>

<!--指定要代理的方法-->
<property name="patterns">
<value>.*doAuditing.* </value>
</property>
</bean>

<!--设定代理类-->
<bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="proxyInterfaces">
<value>com.gc.impl.TimeBookInterface</value>
</property>

<property name="target">
<ref bean="timeBook"/>
</property>

<property name="interceptorNames">
<list>
<value>logAdvisor</value>
</list>
</property>
</bean>
</beans>

5. 写出创建代理对象需指定的三要素是什么?

实现的接口/被代理的对象是谁/ 5种通知中的哪个或哪几个
6:写出代理的两种方式分别是什么?
java用的是动态代理实现的AOP,而非静态代理。
静态代理的方式:是编译器就确定好了的。

动态代理两种实现方法:
1: 基于java JDK 的动态代理。
public class DynamicProxy implements InvocationHandler {

private Object target; // 被代理的对象
public Object bind(Object target) { // 把这个代理和目标绑定,需要proxy也实现和目标一样的接口
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面之前执行");
// 执行业务
method.invoke(target, args);
System.out.println("切面之后执行");
return null;
}

DynamicProxy proxy = new DynamicProxy();
BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
bookProxy.addBook();
2:
public class BookFacadeCglib implements MethodInterceptor {
private Object target;

/**
* 创建代理对象
*
* @param target
* @return
*/
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}

@Override
// 回调方法
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("事物开始");
proxy.invokeSuper(obj, args);
System.out.println("事物结束");
return null;

}

Spring中AOP的两种动态的两种方式
1.是用java反射机制,只能对实现了接口的类生成代理,而不能针对类
2.cgLib 可以不用接口,它底层调用asm 动态生成一个代理类去覆盖父类中非 final 的方法,然后实现 MethodInterceptor 接口的 intercept 方法,这样以后直接调用重写的方法,比 JDK 要快。但是加载 cglib 消耗时间比直接 JDK 反射时间长,开发的过程中,如果是反复动态生成新的代理类推荐用 JDK 自身的反射,反之用 cglib。

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

JDK动态代理和CGLIB字节码生成的区别?
* JDK动态代理只能对实现了接口的类生成代理,而不能针对类
* CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法
因为是继承,所以该类或方法最好不要声明成final

7: AOP事务的含义:

切面:
1: 通知(advice):
就是你想要的功能,也就是安全、事物、日志等。先定义好,在想用的地方用一下。包含Aspect的一段代码
2: 连接点(joinPoint):
spring允许你通知的地方,很多,基本每个方法的前、后,或抛出异常时都可以是连接点。
spring 只支持方法连接点。 其它如AspectJ还可以让你在构造器或属性注入时都行。
3: 切入点(pointcut):
一个类,15个方法,就是15个连接点,但是你不想在所有的方法都用通知,只是让其中几个,在调用这个方法之前,之后
或者抛出异常的时候干点什么,那么就用切入点来定义这几个方法,让切入点选择连接点,选中那几个你想要的方法。
4: 切面(Aspect)
切面是通知和切入点的结合,连接点只是为了让理解切点搞出来的,通知说明了干什么和什么时候干(before,afer等
定义了通知干活的时间)切入点说明了在哪干(就是指明方法)
5: 引入(introduction)
允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗。
可以无需修改现有的类的情况下,让他们有新的行为和状态。
6: 目标(target)
引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被织入切面。自己
只是关注业务本身逻辑。
7:代理(proxy): 由AOP生成的java对象。
8: 织入(weaving):把切面应用到目标对象来创建新的代理对象的过程。有3种方式。
编译期: 切面在目标类编译期被织入,这种方式需要特殊的编译器,如AspectJ.
类加载期: 切面在目标类加载到JVM时被织入,这种方式要特殊的类加载器。
运行期: Spring AOP用的这种方式。
9: 横切关注点: log\安全检查等。
AOP原理: 在不需要改变现有代码的前提下,增加功能。
spring 用代理类包裹切面,把他们织入到spring管理的bean中,也就是说代理类伪装成目标类,它会截取对目标类中方法
的调用,调用者对目标类对调用都先变成伪装类,伪装类先执行切面,再把调用转给真正目标bean。
如何搞出个伪装类,才不会被调用者发现,如下两种方法:
1) 实现和目标类相同的接口:
我也实现和你一样的接口,反正上层都是接口级别的调用,逃过了类型检查,到java运行期的时候,利用多态的后期绑定(所以spring
采用运行时),伪装类(代理类)就变成了接口的真正实现,他里面包裹了真实的目标类,最后实现具体功能的还是目标类,伪装类干了点
额外的事情(写日志、安全检查、事物等)。
这种模式,spring用JDK的java.lang.reflect.Proxy类,它允许Spring动态生成一个新类来实现必要的接口,织入通知,并且把
这些接口的任何调用都转发到目标类。
2) 生成子类调用
用子类做伪装,逃过类型检查,重写的方法实现了目标类的功能,还在这些功能之前,实现了一些其它的(写日志,安全检查,事物)
spring使用CGLIB库生成目标类的一个子类,在创建这个子类的时候,spring织入通知。
前一种模式更好,松耦合,尤其在今天高喊着面向接口编程的情况下。
它可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术.如果您学习Java的话,会在Spring中经常用到,那是你更能领悟它
主要的功能是:日志记录,性能统计,安全控制,事务处理,异常处理,Caching 缓存
等等。 从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。

http://www.hongyanliren.com/2014m12/22797.html

1: 通知(advice):
就是你想要的功能,也就是安全、事物、日子等。先定义好,在想用的地方用一下。包含Aspect的一段代码
2: 连接点(joinPoint):
spring允许你通知的地方,很多,基本每个方法的前、后,或抛出异常时都可以是连接点。
spring 只支持方法连接点。 其它如AspectJ还可以让你在构造器或属性注入时都行。
3: 切入点(pointcut):
一个类,15个方法,就是15个连接点,但是你不想在所有的方法都用通知,只是让其中几个,在调用这个方法之前,之后
或者抛出异常的时候干点什么,那么就用切入点来定义这几个方法,让切入点选择连接点,选中那几个你想要的方法。
4: 切面(Aspect)
切面是通知advice和切入点的结合,连接点只是为了让理解切点搞出来的,通知说明了干什么和什么时候干(before,afer等
定义了通知干活的时间)切入点说明了在哪干(就是指明方法)
5: 引入(introduction)
允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗。
可以无需修改现有的类的情况下,让他们有新的行为和状态。
6: 目标(target)
引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被织入切面。自己
只是关注业务本身逻辑。
7:代理(proxy): 由AOP生成的java对象。
8: 织入(weaving):把切面应用到目标对象来创建新的代理对象的过程。有3种方式。
编译期: 切面在目标类编译期被织入,这种方式需要特殊的编译器,如AspectJ.
类加载期: 切面在目标类加载到JVM时被织入,这种方式要特殊的类加载器。
运行期: Spring AOP用的这种方式。
9: 横切关注点: log\安全检查等。

AOP原理:
spring 用代理类包裹切面,把他们织入到spring管理的bean中,也就是说代理类伪装成目标类,它会截取对目标类中方法
的调用,调用者对目标类对调用都先变成伪装类,伪装类先执行切面,再把调用转给真正目标bean。

如何搞出个伪装类,才不会被调用者发现,如下两种方法:
1) 实现和目标类相同的接口:
我也实现和你一样的接口,反正上层都是接口级别的调用,逃过了类型检查,到java运行期的时候,利用多态的后期绑定(所以spring
采用运行时),伪装类(代理类)就变成了接口的真正实现,他里面包裹了真实的目标类,最后实现具体功能的还是目标类,伪装类干了点
额外的事情(写日志、安全检查、事物等)。

这种模式,spring用JDK的java.lang.reflect.Proxy类,它允许Spring动态生成一个新类来实现必要的接口,织入通知,并且把
这些接口的任何调用都转发到目标类。

2) 生成子类调用
用子类做伪装,逃过类型检查,重写的方法实现了目标类的功能,还在这些功能之前,实现了一些其它的(写日志,安全检查,事物)

spring使用CGLIB库生成目标类的一个子类,在创建这个子类的时候,spring织入通知。

前一种模式更好,松耦合,尤其在今天高喊着面向接口编程的情况下。

面向切面编程,在我们的应用中,经常需要做一些事情,但是这些事情与核心业务无关,比如,要记录所有update*方法的执行时间时间,操作人等等信息,记录到日志,

通过spring的AOP技术,就可以在不修改update*的代码的情况下完成该需求。

AOP实现原理-----代理

////////////////////////////////////////////////////////////////////////////////////
1: Spring通知几种类型?
org.aopalliance.intercept.MethodInterceptor
org.springframework.aop.MethodBeforeAdvice
org.springframework.aop.AfterReturningAdvice
org.springframework.aop.ThrowsAdvice
2. 谈谈目标对象实现接口与目标对象不实现接口有什么区别?
其中动态代理又可分为:
1.JDK动态代理
此时代理对象和目标对象实现了相同的接口,目标对象作为代理对象的一个属性,具体接口实现中,可以在调用目标对象相应方法前后加上其他业务处理逻辑。
代理模式在实际使用时需要指定具体的目标对象,如果为每个类都添加一个代理类的话,会导致类很多,同时如果不知道具体类的话,怎样实现代理模式呢?这就引出动态代理。
JDK动态代理只能针对实现了接口的类生成代理。
2.CGLIB代理
CGLIB(CODE GENERLIZE LIBRARY)代理是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的所有方法,所以该类或方法不能声明称final的。

3. 请描述JDK动态代理和CGLI代理的区别?
4:简述ProxyFactoryBean的作用是什么?
使用Spring提供的类org.springframework.aop.framework.ProxyFactoryBean是创建AOP的最基本的方式 .

第一种方式: 使用ProxyFactoryBean代理目标类的所有方法
<bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<!--这里代理的是接口-->
<property name="proxyInterfaces">
<value>com.gc.impl.TimeBookInterface</value>
</property>

<!--是ProxyFactoryBean要代理的目标类-->
<property name="target">
<ref bean="timeBook"/>
</property>

<!--程序中的Advice-->
<property name="interceptorNames">
<list>
<value>log</value> // 这里的log可以是5中通知中的一种。
</list>
</property>
</bean>
</beans>

第二种方式: 使用ProxyFactoryBean代理目标类的指定方法:
<bean id="logAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref bean="log"/>
</property>

<!--指定要代理的方法-->
<property name="patterns">
<value>.*doAuditing.* </value>
</property>
</bean>

<!--设定代理类-->
<bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="proxyInterfaces">
<value>com.gc.impl.TimeBookInterface</value>
</property>

<property name="target">
<ref bean="timeBook"/>
</property>

<property name="interceptorNames">
<list>
<value>logAdvisor</value>
</list>
</property>
</bean>
</beans>

5. 写出创建代理对象需指定的三要素是什么?

实现的接口/被代理的对象是谁/ 5种通知中的哪个或哪几个
6:写出代理的两种方式分别是什么?
java用的是动态代理实现的AOP,而非静态代理。
静态代理的方式:是编译器就确定好了的。

动态代理两种实现方法:
1: 基于java JDK 的动态代理。
public class DynamicProxy implements InvocationHandler {

private Object target; // 被代理的对象
public Object bind(Object target) { // 把这个代理和目标绑定,需要proxy也实现和目标一样的接口
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面之前执行");
// 执行业务
method.invoke(target, args);
System.out.println("切面之后执行");
return null;
}

DynamicProxy proxy = new DynamicProxy();
BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
bookProxy.addBook();
2:
public class BookFacadeCglib implements MethodInterceptor {
private Object target;

/**
* 创建代理对象
*
* @param target
* @return
*/
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}

@Override
// 回调方法
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("事物开始");
proxy.invokeSuper(obj, args);
System.out.println("事物结束");
return null;

}

Spring中AOP的两种动态的两种方式
1.是用java反射机制,只能对实现了接口的类生成代理,而不能针对类
2.cgLib 可以不用接口,它底层调用asm 动态生成一个代理类去覆盖父类中非 final 的方法,然后实现 MethodInterceptor 接口的 intercept 方法,这样以后直接调用重写的方法,比 JDK 要快。但是加载 cglib 消耗时间比直接 JDK 反射时间长,开发的过程中,如果是反复动态生成新的代理类推荐用 JDK 自身的反射,反之用 cglib。

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

JDK动态代理和CGLIB字节码生成的区别?
* JDK动态代理只能对实现了接口的类生成代理,而不能针对类
* CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法
因为是继承,所以该类或方法最好不要声明成final

7: AOP事务的含义:

切面:
1: 通知(advice):
就是你想要的功能,也就是安全、事物、日志等。先定义好,在想用的地方用一下。包含Aspect的一段代码
2: 连接点(joinPoint):
spring允许你通知的地方,很多,基本每个方法的前、后,或抛出异常时都可以是连接点。
spring 只支持方法连接点。 其它如AspectJ还可以让你在构造器或属性注入时都行。
3: 切入点(pointcut):
一个类,15个方法,就是15个连接点,但是你不想在所有的方法都用通知,只是让其中几个,在调用这个方法之前,之后
或者抛出异常的时候干点什么,那么就用切入点来定义这几个方法,让切入点选择连接点,选中那几个你想要的方法。
4: 切面(Aspect)
切面是通知和切入点的结合,连接点只是为了让理解切点搞出来的,通知说明了干什么和什么时候干(before,afer等
定义了通知干活的时间)切入点说明了在哪干(就是指明方法)
5: 引入(introduction)
允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗。
可以无需修改现有的类的情况下,让他们有新的行为和状态。
6: 目标(target)
引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被织入切面。自己
只是关注业务本身逻辑。
7:代理(proxy): 由AOP生成的java对象。
8: 织入(weaving):把切面应用到目标对象来创建新的代理对象的过程。有3种方式。
编译期: 切面在目标类编译期被织入,这种方式需要特殊的编译器,如AspectJ.
类加载期: 切面在目标类加载到JVM时被织入,这种方式要特殊的类加载器。
运行期: Spring AOP用的这种方式。
9: 横切关注点: log\安全检查等。
AOP原理: 在不需要改变现有代码的前提下,增加功能。
spring 用代理类包裹切面,把他们织入到spring管理的bean中,也就是说代理类伪装成目标类,它会截取对目标类中方法
的调用,调用者对目标类对调用都先变成伪装类,伪装类先执行切面,再把调用转给真正目标bean。
如何搞出个伪装类,才不会被调用者发现,如下两种方法:
1) 实现和目标类相同的接口:
我也实现和你一样的接口,反正上层都是接口级别的调用,逃过了类型检查,到java运行期的时候,利用多态的后期绑定(所以spring
采用运行时),伪装类(代理类)就变成了接口的真正实现,他里面包裹了真实的目标类,最后实现具体功能的还是目标类,伪装类干了点
额外的事情(写日志、安全检查、事物等)。
这种模式,spring用JDK的java.lang.reflect.Proxy类,它允许Spring动态生成一个新类来实现必要的接口,织入通知,并且把
这些接口的任何调用都转发到目标类。
2) 生成子类调用
用子类做伪装,逃过类型检查,重写的方法实现了目标类的功能,还在这些功能之前,实现了一些其它的(写日志,安全检查,事物)
spring使用CGLIB库生成目标类的一个子类,在创建这个子类的时候,spring织入通知。
前一种模式更好,松耦合,尤其在今天高喊着面向接口编程的情况下。
它可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术.如果您学习Java的话,会在Spring中经常用到,那是你更能领悟它
主要的功能是:日志记录,性能统计,安全控制,事务处理,异常处理,Caching 缓存
等等。 从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。

Spring 学习十五 AOP的更多相关文章

  1. Java开发学习(十五)----AOP入门案例及其工作流程解析

    一.AOP简介 1.1 什么是AOP AOP(Aspect Oriented Programming)面向切面编程,一种编程范式,指导开发者如何组织程序结构. OOP(Object Oriented ...

  2. Spring学习(十五)----- Spring AOP通知实例 – Advice

    Spring AOP(面向方面编程)框架,用于在模块化方面的横切关注点.简单得说,它只是一个拦截器拦截一些过程,例如,当一个方法执行,Spring AOP 可以劫持一个执行的方法,在方法执行之前或之后 ...

  3. Spring学习十五----------Spring AOP API的Pointcut、advice及 ProxyFactoryBean相关内容

    © 版权声明:本文为博主原创文章,转载请注明出处 实例: 1.项目结构 2.pom.xml <project xmlns="http://maven.apache.org/POM/4. ...

  4. spring学习 十五 spring的自动注入

    一  :在 Spring 配置文件中对象名和 ref=”id” ,id 名相同使用自动注入,可以不配置<property/>,对应的注解@Autowired的作用 二: 两种配置办法 (1 ...

  5. spring 学习(五):spring 事务

    spring 学习(五):spring 事务 事务概要 一个数据库事务通常包含了一个序列的对数据库的读/写操作.它的存在包含有以下两个目的: 为数据库操作序列提供了一个从失败中恢复到正常状态的方法,同 ...

  6. Spring Boot(十五):spring boot+jpa+thymeleaf增删改查示例

    Spring Boot(十五):spring boot+jpa+thymeleaf增删改查示例 一.快速上手 1,配置文件 (1)pom包配置 pom包里面添加jpa和thymeleaf的相关包引用 ...

  7. Spring学习笔记之aop动态代理(3)

    Spring学习笔记之aop动态代理(3) 1.0 静态代理模式的缺点: 1.在该系统中有多少的dao就的写多少的proxy,麻烦 2.如果目标接口有方法的改动,则proxy也需要改动. Person ...

  8. Spring学习(十八)----- Spring AOP+AspectJ注解实例

    我们将向你展示如何将AspectJ注解集成到Spring AOP框架.在这个Spring AOP+ AspectJ 示例中,让您轻松实现拦截方法. 常见AspectJ的注解: @Before – 方法 ...

  9. Spring学习笔记4——AOP

    AOP 即 Aspect Oriented Program 面向切面编程 首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能. 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务 ...

随机推荐

  1. 如何使用Django实现用户登录验证

    最初开始搞用户登录验证的时候感觉没什么难的,不就是增删改查中的查询数据库么,但是还是遇到许多小问题,而且感觉在查询数据库的时候,要把前端的数据一条一条的进行比对,会导致我的代码很丑,而且方式很不智,所 ...

  2. 关于matlab曲线拟合的问题

    matlab 曲线拟合工具箱,app->curve fitting 可以使用generate直接产生代码,生成的是函数 该函数直接返回的结果为cfit格式,直接读取不了,网上有网友说可以采用y ...

  3. LyX中文配置

    环境:OS X 10.9; MacTeX-2014; LyX Version 2.1.0 LyX是一个“WYSIWYM”(What You See Is What You Mean)的文字排版系统.其 ...

  4. mysql 中 all any some 用法

    -- 建表语句 CREATE TABLE score( id INT PRIMARY KEY AUTO_INCREMENT, NAME ), SUBJECT ), score INT); -- 添加数 ...

  5. Microsoft Office Document Imaging批量ocr 方法

    先将pdf文件->导出->tiff文件,生成pdf每页的tiff文件 使用 G:\SoftWare-new\tiff文件合并拆分工具 将一个导出的单个tiff合并为一个tiff文件 再用 ...

  6. HDU - 5550 Game Rooms 【DP+前缀和】

    题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=5550 题意 一撞大楼有N层楼,然后每层楼都有一部分人喜欢打羽毛球,一部分人喜欢打乒乓球 但是每层楼只能 ...

  7. Vim 的命令模式转插入模式

    一.在命令模式输入下面的快捷方式: i 在当前光标前插入字符: I 在当前行行首插入字符: a 在当前光标后插入字符: A 在当前行行尾插入字符: o 在当前行下面另起一新行: O 在当前行上面另起一 ...

  8. Struts2 内核之我见

    Struts2 内核之我见 完整分析 Struts2 内核中文文档 本文首先探讨了 Struts2 核心控制器的源码,以帮助解读 Struts2 的工作流程.接着讲解相关外围类.最后对 Struts ...

  9. python第八篇:十分钟学会Flask

    什么是Flask Flask是一个基于Python并且依赖于Jinja2模板引擎和Werkzeug WSGI服务的一个微型框架 Flask中包含一个轻量级的web 服务器主要用于在开发阶段测试使用 F ...

  10. 重置 oschina 的CSS

    嗯, 目前只是改了一下OSChina的几个主要DIV宽度而以,还是很粗糙, 以后会慢慢改进的. ---------------------------------------------------- ...