Spring4学习回顾之路11-AOP
Srping的核心除了之前讲到的IOC/DI之外,还有一个AOP(Aspect Oriented Programming:面向切面编程):通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。主要的功能: 日志记录,性能统计,安全控制,事务处理,异常处理等等。
在介绍AOP之前,先介绍动态代理;代理设计模式的原理:使用一个代理将对象包装起来,然后用该代理对象取代原始对象,任何对原始对象的调用都要通过代理,代理对象决定是否以及何时将方法调用转到原始对象上。
案例:基于接口实现的动态代理:JDK动态代理
首先定义一个接口,用于运算的Operation.java
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public interface Operation { //加法
int add(int i,int j); //减法
int sub(int i,int j); }
再来定义实现类OperationImpl.java
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class OperationImpl implements Operation { @Override
public int add(int i, int j) {
return 0;
} @Override
public int sub(int i, int j) {
return 0;
}
}
现在的需求就是用硬编码的形式添加日志,传统的做法是:
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class OperationImpl implements Operation { @Override
public int add(int i, int j) {
System.out.println("两数相加的参数为:" + i + "+" + j);
int result = i+j;
System.out.println("两数相加的结果为:" + result);
return result;
} @Override
public int sub(int i, int j) {
System.out.println("两数相减的参数为:" + i + "-" + j);
int result = i-j;
System.out.println("两数相减的结果为:" + result);
return result;
}
}
测试代码和结果为:
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class Test { public static void main(String[] args) { Operation op = new OperationImpl();
System.out.println(op.add(1, 2));
System.out.println(op.sub(4,2));
}
} 两数相加的参数为:1+2
两数相加的结果为:3
3
两数相减的参数为:4-2
两数相减的结果为:2
2
显然这么操作是不合理,但是JDK的动态代理就能很好的解决这个问题;如下所示:
还原最初版本的OperationImplProxy.java
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class OperationImplProxy implements Operation { @Override
public int add(int i, int j) {
int result = i+j;
return result;
} @Override
public int sub(int i, int j) {
int result = i-j;
return result;
}
}
编写代理类OperationProxy.java:
package com.lql.proxy; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays; /**
* @author: lql
* @date: 2019.10.29
* Description:
* Created with IntelliJ IDEA
*/
public class OperationProxy { //代理对象
private Operation target; public OperationProxy(Operation target) {
this.target = target;
} //获取代理对象
public Operation getInstance() { Operation proxy = null; ClassLoader loader = target.getClass().getClassLoader(); Class[] clazz= target.getClass().getInterfaces(); InvocationHandler in = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String name = method.getName();
System.out.println("方法名:" + name + ",参数:" + Arrays.asList(args));
Object result = method.invoke(target, args);
System.out.println("结果:" + result);
return result;
}
};
proxy = (Operation) Proxy.newProxyInstance(loader, clazz, in);
return proxy;
}
}
测试类和结果:
package com.lql.proxy; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class Test { public static void main(String[] args) {
// Operation op = new OperationImpl();
// System.out.println(op.add(1, 2));
// System.out.println(op.sub(4,2)); Operation target = new OperationImplProxy();
Operation operation = new OperationProxy(target).getInstance(); System.out.println(operation.add(1, 2));
System.out.println(operation.sub(4, 2));
}
} 方法名:add,参数:[1, 2]
结果:3
3
方法名:sub,参数:[4, 2]
结果:2
2
至此JDK的动态代理demo完成了,这里就不详细介绍每一步了。回归正题:AOP:面向切面编程,相较于传统的OOP(面向对象编程)来说是个补充;说到AOP那就不得不提及它的相关术语了:
-切面(Aspect):横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
-通知(advice): 切面必须要完成的功能
-目标(target) : 被通知的对象
-代理(Proxy) :向目标对象应用通知之后创建的对象
-连接点(Joinpoint): 程序执行的某个特定位置
-切点(pointcut):每个类都拥有多个连接点
关于AOP的基础配置先出个总图有个印象:
在Spring2.0以上的版本中,可以使用基于AspectJ注解或者基于XML配置的AOP;其中AspectJ是Java社区里最完整流行的AOP框架。
一:基于注解方式:
①:前置通知:
先导入需要的jar包
建立Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <!--配置自动扫描的包-->
<context:component-scan base-package="com.lql.spring07"/> <!--使AspectJ注解起作用,自动为匹配的类生成代理对象-->
<aop:aspectj-autoproxy/>
</beans>
建立接口
package com.lql.spring07; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public interface Operation { //加法
int add(int i, int j); //减法
int sub(int i, int j); }
建立接口实现
package com.lql.spring07; import com.lql.proxy.Operation;
import org.springframework.stereotype.Component; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
public class OperationImpl implements Operation { @Override
public int add(int i, int j) {
int result = i+j;
return result;
} @Override
public int sub(int i, int j) {
int result = i-j;
return result;
}
}
测试类和结果
package com.lql.spring07; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
public class Test { public static void main(String[] args) { ApplicationContext app = new ClassPathXmlApplicationContext("aop.xml");
OperationImpl bean = app.getBean("operationImpl", OperationImpl.class);
System.out.println(bean.add(2, 2));
System.out.println(bean.sub(4, 2));
}
} 4
2
这样是没有问题的,现在开始给程序增加日志功能,也就是完成之前动态代理的活;
首先是需要定义切面,并把该切面放入IOC容器中,定义如下:先简单完成,后完善功能,具体语法稍后解释!
package com.lql.spring07; import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect { //声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before() {
System.out.println("方法前被调用");
}
}
再次执行测试类结果:
方法前被调用
4
方法前被调用
2
接下来完善日志信息:
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect {
//声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("方法名称: " + methodName + ",参数为 : " + args);
}
}
结果如下:
方法名称: add,参数为 : [2, 2]
4
方法名称: sub,参数为 : [4, 2]
2
关于@Before(value = "execution(* com.lql.spring07.*.*(..))")后面中的一大串其实就是AspectJ的表达式,具体使用(如果看不懂可以直接写完整的方法):
-里面的组成: execution(修饰符匹配 ? 返回值类型匹配操作类型匹配 ? 名称匹配(参数匹配)抛出异常匹配);
*.*描述的是这个包中所有类中所有的方法,不想全部可以细分
(..)描述的是参数
com.lql.spring07是切入点匹配的包名称,如果多层则可以使用..代替比如:com.lql..service.spring07
第一个*则表示该方法的返回值,任意数据类型,当然前面也能增加访问修饰符public或者private
②:后置通知:
在之前的代码中新增后置通知:
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect { //声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println("方法名称: " + methodName + ",参数为 : " + args); } //后置通知:方法执行后执行,无论是否执行完毕
@After("execution(* com.lql.spring07.*.*(..))")
public void after(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName(); System.out.println("方法名称: " + methodName + "执行完毕");
}
}
执行结果为:
方法名称: add,参数为 : [2, 2]
方法名称: add执行完毕
4
方法名称: sub,参数为 : [4, 2]
方法名称: sub执行完毕
2
需要注意的是:在后置通知的时候还不能获取目标方法的处理结果!
③:返回通知:
在原先的LogAspect中继续追加返回通知
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect { //声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println("方法名称: " + methodName + ",参数为 : " + args); } //后置通知:方法执行后执行,无论是否执行完毕
@After("execution(* com.lql.spring07.*.*(..))")
public void after(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName(); System.out.println("方法名称: " + methodName + "执行完毕");
} /**
* 返回通知:在方法正常结束时执行的代码
* @param joinPoint 连接点,可以获取详细信息
* @param result 接收到的返回值
*/
@AfterReturning(value = "execution(* com.lql.spring07.*.*(..))",returning = "result")
public void afterReturn(JoinPoint joinPoint,Object result) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()计算结果为:" + result);
} }
执行结果:
方法名称: add,参数为 : [2, 2]
方法名称: add执行完毕
add()计算结果为:4
4
方法名称: sub,参数为 : [4, 2]
方法名称: sub执行完毕
sub()计算结果为:2
2
④:异常通知:
先修改OperationImpl的sub(),手动抛出一个异常
@Override
public int sub(int i, int j) {
int result = i-j;
throw new RuntimeException();
}
修改LogAspect:增加异常通知
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect { //声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println("方法名称: " + methodName + ",参数为 : " + args); } //后置通知:方法执行后执行,无论是否执行完毕
@After("execution(* com.lql.spring07.*.*(..))")
public void after(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName(); System.out.println("方法名称: " + methodName + "执行完毕");
} /**
* 返回通知:在方法正常结束时执行的代码
* @param joinPoint 连接点,可以获取详细信息
* @param result 接收到的返回值
*/
@AfterReturning(value = "execution(* com.lql.spring07.*.*(..))",returning = "result")
public void afterReturn(JoinPoint joinPoint,Object result) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()计算结果为:" + result);
} /**
* 异常通知:在目标方法出现异常时会执行,可以访问到异常对象,也能指定具体的异常后执行代码
* @param joinPoint 连接点,可以获取详细信息
* @param e 捕获异常信息
*/
@AfterThrowing(value = "execution(* com.lql.spring07.*.*(..))",throwing = "e")
public void afterThrowing(JoinPoint joinPoint,Exception e) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()异常为 :" +e);
} }
执行结果为:
方法名称: add,参数为 : [2, 2]
方法名称: add执行完毕
add()计算结果为:4
4
方法名称: sub,参数为 : [4, 2]
方法名称: sub执行完毕
sub()异常为 :java.lang.RuntimeException
Exception in thread "main" java.lang.RuntimeException...
⑤:环绕通知:
环绕通知几乎能干上述四种通知,比较全能,就相当于动态代理的全过程,但是不一定是最好的。为了观赏性,取消上述定义的手工抛异常,修改LogAspect.java,取消之前定义好的所有通知,只留下环绕通知:
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Component
@Aspect
public class LogAspect {
/**
* 环绕通知:需要携带ProceedingJoinPoint类型的参数,环绕通知类似于动态代理的全过程
*
* @param join 可以决定是否执行目标方法
* 环绕通知必须由返回值,返回值即为目标方法的返回值
*/
@Around("execution(* com.lql.spring07.*.*(..))")
public Object around(ProceedingJoinPoint join) { Object result = null;
String methodName = join.getSignature().getName();
try {
//前置通知
System.out.println(methodName + "()方法,参数为:" + Arrays.asList(join.getArgs()));
//执行目标方法
result = join.proceed();
//返回通知
System.out.println(methodName + "()方法返回值为:" + result);
} catch (Throwable throwable) {
throwable.printStackTrace();
//异常通知
System.out.println(methodName + "()方法出现的异常为:" + throwable);
}
//后置通知
System.out.println(methodName + "()方法执行完毕");
return result;
} }
执行结果:
add()方法,参数为:[2, 2]
add()方法返回值为:4
add()方法执行完毕
4
sub()方法,参数为:[4, 2]
sub()方法返回值为:2
sub()方法执行完毕
2
如果有异常,那么结果为:
至此,五大通知就告一段落了,我们也可以给切面定义优先级,如果有多个切面,可以在每个切面上使用@Order来标明优先级,比如这样
@Order后面的数值越小,优先级就越高!
所以上述完整的切面代码如下所示:
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Order(2)
@Component
@Aspect
public class LogAspect {
//声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "execution(* com.lql.spring07.*.*(..))")
public void before(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("方法名称: " + methodName + ",参数为 : " + args); } //后置通知:方法执行后执行,无论是否执行完毕
@After("execution(* com.lql.spring07.*.*(..))")
public void after(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName(); System.out.println("方法名称: " + methodName + "执行完毕");
} /**
* 返回通知:在方法正常结束时执行的代码
* @param joinPoint 连接点,可以获取详细信息
* @param result 接收到的返回值
*/
@AfterReturning(value = "execution(* com.lql.spring07.*.*(..))",returning = "result")
public void afterReturn(JoinPoint joinPoint,Object result) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()计算结果为:" + result);
} /**
* 异常通知:在目标方法出现异常时会执行,可以访问到异常对象,也能指定具体的异常后执行代码
* @param joinPoint 连接点,可以获取详细信息
* @param e 捕获异常信息
*/
@AfterThrowing(value = "execution(* com.lql.spring07.*.*(..))",throwing = "e")
public void afterThrowing(JoinPoint joinPoint,Exception e) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()异常为 :" +e);
} /**
* 环绕通知:需要携带ProceedingJoinPoint类型的参数,环绕通知类似于动态代理的全过程
*
* @param join 可以决定是否执行目标方法
* 环绕通知必须由返回值,返回值即为目标方法的返回值
*/
@Around("execution(* com.lql.spring07.*.*(..))")
public Object around(ProceedingJoinPoint join) { Object result = null;
String methodName = join.getSignature().getName();
try {
//前置通知
System.out.println(methodName + "()方法,参数为:" + Arrays.asList(join.getArgs()));
//执行目标方法
result = join.proceed();
//返回通知
System.out.println(methodName + "()方法返回值为:" + result);
} catch (Throwable throwable) {
throwable.printStackTrace();
//异常通知
System.out.println(methodName + "()方法出现的异常为:" + throwable);
}
//后置通知
System.out.println(methodName + "()方法执行完毕");
return result;
} }
不难看出上面用粗体标识的代码太过重复,以后维护也不容易,所以有个重用切点的概念!使用@PointCut来声明切入点表达式,后面的其他通知使用到的时候直接引用方法名即可,定义如下:
@Pointcut(value ="execution(* com.lql.spring07.*.*(..))")
public void ref(){}
更换后完整的代码:
package com.lql.spring07; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component; import java.util.Arrays;
import java.util.List; /**
* @author: lql
* @date: 2019.10.29
* Description:
*/
@Order(2)
@Component
@Aspect
public class LogAspect { @Pointcut(value ="execution(* com.lql.spring07.*.*(..))")
public void ref(){} //声明该方法是个前置通知,在目标方法执行前执行
@Before(value = "ref()")
public void before(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("方法名称: " + methodName + ",参数为 : " + args); } //后置通知:方法执行后执行,无论是否执行完毕
@After("ref()")
public void after(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName(); System.out.println("方法名称: " + methodName + "执行完毕");
} /**
* 返回通知:在方法正常结束时执行的代码
* @param joinPoint 连接点,可以获取详细信息
* @param result 接收到的返回值
*/
@AfterReturning(value = "ref()",returning = "result")
public void afterReturn(JoinPoint joinPoint,Object result) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()计算结果为:" + result);
} /**
* 异常通知:在目标方法出现异常时会执行,可以访问到异常对象,也能指定具体的异常后执行代码
* @param joinPoint 连接点,可以获取详细信息
* @param e 捕获异常信息
*/
@AfterThrowing(value = "ref()",throwing = "e")
public void afterThrowing(JoinPoint joinPoint,Exception e) {
String name = joinPoint.getSignature().getName();
System.out.println(name +"()异常为 :" +e);
} /**
* 环绕通知:需要携带ProceedingJoinPoint类型的参数,环绕通知类似于动态代理的全过程
*
* @param join 可以决定是否执行目标方法
* 环绕通知必须由返回值,返回值即为目标方法的返回值
*/
@Around("ref()")
public Object around(ProceedingJoinPoint join) { Object result = null;
String methodName = join.getSignature().getName();
try {
//前置通知
System.out.println(methodName + "()方法,参数为:" + Arrays.asList(join.getArgs()));
//执行目标方法
result = join.proceed();
//返回通知
System.out.println(methodName + "()方法返回值为:" + result);
} catch (Throwable throwable) {
throwable.printStackTrace();
//异常通知
System.out.println(methodName + "()方法出现的异常为:" + throwable);
}
//后置通知
System.out.println(methodName + "()方法执行完毕");
return result;
} }
二:基于配置文件的方式配置AOP
首先统统还原为最原始的样子,去掉所有的注解!xml配置如下
<?xml version="1.0" encoding="UTF-8"?>
<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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <!--配置bean-->
<bean id="operationImpl" class="com.lql.spring08.OperationImpl"></bean> <!--配置切面的Bean-->
<bean id="logAspect" class="com.lql.spring08.LogAspect"></bean> <!--配置AOP-->
<aop:config>
<!--配置切点表达式-->
<aop:pointcut id="pointcut" expression="execution(* com.lql.spring08.*.*(..))"/> <!--配置切面及通知-->
<aop:aspect ref="logAspect" order="2">
<aop:before method="before" pointcut-ref="pointcut"></aop:before>
<aop:after method="after" pointcut-ref="pointcut"></aop:after>
<aop:after-returning method="afterReturn" pointcut-ref="pointcut" returning="result"></aop:after-returning>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"></aop:after-throwing>
</aop:aspect>
<!--可以定义多个切面,如这样-->
<aop:aspect ref="logAspect2" order="1">
<!--省略。。。-->
</aop:aspect>
</aop:config>
</beans>
运行结果如:
方法名称: add,参数为 : [2, 2]
方法名称: add执行完毕
add()计算结果为:4
4
方法名称: sub,参数为 : [4, 2]
方法名称: sub执行完毕
sub()计算结果为:2
2
Spring4学习回顾之路11-AOP的更多相关文章
- Spring4学习回顾之路01—HelloWorld
以前公司一直使用的是spring3.0,最近一段时间开始用了4.0,官网上都已经有了5.0,但是很多知识点已经忘了差不多了,趁现在项目不忙写写随笔,一来回顾自己的知识点,二来如果能帮助比我还小白的小白 ...
- Spring4学习回顾之路12-事务
事务:事务就是一系列的动作,它们被当做一个单独的工作单元,这些动作要么全部完成,要么全部不起作用:事务管理是企业级应用程序开发中必不可少的技术,用来确保数据的完整性和一致性.事务的四个关键属性(ACI ...
- Spring4学习回顾之路04—引用其他Bean,集合数据注入,内部Bean
引用其他Bean 组件应用程序的Bean经常需要相互协作以完成应用程序的功能,所以要求Bean能够相互访问,就必须在Bean配置文件中指定Bean的引用.在Bean的配置文件中可以用过<ref& ...
- Spring4学习回顾之路10-Spring4.x新特性:泛型依赖注入
泛型依赖注入:Spring 4.x中可以为子类注入子类对应的泛型类型的成员变量的引用. 话语太过抽象,直接看代码案例,依次建立如下代码: User.java package com.lql.sprin ...
- Spring4学习回顾之路09-基于注解的方式配置bean
一:基于注解配置Bean 首先介绍下组件扫描(component scanning): Spring能够从classpath下自动扫描,侦测和实例化具有特定注解的组件. 包括: -@Component ...
- Spring4学习回顾之路08- FactoryBean配置Bean
建立Student.java package com.lql.srping04; /** * @author: lql * @date: 2019.10.28 * Description: */ pu ...
- Spring4学习回顾之路07- 通过工厂方法配置Bean
一:通过静态工厂配置Bean 建立Student.java package com.lql.srping04; /** * @author: lql * @date: 2019.10.28 * Des ...
- Spring4学习回顾之路06- IOC容器中Bean的生命周期方法
SpringIOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行特定的任务! Spring IOC容器对Bean的生命周期进行管理的过程: -通过构造器或者工厂方法创建 ...
- Spring4学习回顾之路05—自动装配,Bean的继承,依赖和作用域
自动装配 xml配置里的Bean的自动装配,Spring IOC容器可以自动装配Bean,仅仅需要做的是在<bean>标签里的autowire属性里指定自动装配的模式. ①byType(根 ...
随机推荐
- CodeForces - 999C Alphabetic Removals
C - Alphabetic Removals ≤k≤n≤4⋅105) - the length of the string and the number of letters Polycarp wi ...
- Win内核原理与实现学习笔记3-windows系统结构
1.概述 1.1windows采用了双模式(dual mode)结构来保护操作系统本身,以避免被应用程序的错误而波及.操作系统核心运行在内核模式(kernel mode)下,应用程序的代码运行在用户模 ...
- P1484 种树——数据结构优先队列
种了一下午的树,终于给搞明白了((多谢各位大神的题解)(题解就不能讲清楚点吗(看不见看不见))): 你有k个树,你可以种在一条直线上,每个位置都有一个价值,如果你把树种在这里就可以获得这个价值,但是条 ...
- php 图片格式转换-亲测ok
代码如下 /** * 图片格式转换 * @param string $image_path 文件路径或url * @param string $to_ext 待转格式,支持png,gif,jpeg,w ...
- AGC024E Sequence Growing Hard
题意 给出\(n\),\(m\),\(mu\),问有多少个序列组\((A_0,A_1,\dots,A_n)\)满足: 序列\(Ai\)的长度恰好为\(i\) 所有元素均在\([1,m]\) \(A_{ ...
- Git生成本机SSH Key并添加到GitHub中
1.检查电脑里是否有SSH Key 打开git Bash客户端 cd ~/.ssh ls 如果有就会输出下面内容 config id_rsa id_rsa.pub known_hosts 2.创建 邮 ...
- RHSA-2018:3059-低危: X.org X11 安全和BUG修复更新
修复命令: yum update libXfontyum update libxcbyum update xorg-x11-font-utilsyum update xorg-x11-utilsyum ...
- 笔记三(UEFI详解)
1.SEC 安全验证 SEC(Security Phase)阶段是平台初始化的第一个阶段,计算机系统加电后进入这个阶段. 1)接收并处理系统启动和重启信号:系统加点信号.系统重启信号.系统运行过程中的 ...
- vue实现购物清单列表添加删除
vue实现购物清单列表添加删除 一.总结 一句话总结: 基础的v-model操作,以及数组的添加(push)删除(splice)操作 1.checkbox可以绑定数组,也可以直接绑定值? 绑定数组就是 ...
- Hadoop常用操作汇总
Hadoop Streaming示例程序(wordcount) run_hadoop_word_counter.sh $HADOOP_BIN streaming \ -input "${IN ...