spring基础之四->Spring AOP介绍与使用

Spring AOP介绍与使用

AOP：Aspect Oriented Programming 面向切面编程

OOP：Object Oriented Programming 面向对象编程

面向切面编程：基于OOP基础之上新的编程思想，OOP面向的主要对象是类，而AOP面向的主要对象是切面，在处理日志、安全管理、事务管理等方面有非常重要的作用。AOP是Spring中重要的核心点，虽然IOC容器没有依赖AOP，但是AOP提供了非常强大的功能，用来对IOC做补充。通俗点说的话就是在程序运行期间，将某段代码动态切入到指定方法的指定位置进行运行的这种编程方式。

1、AOP的概念

为什么要引入AOP?
Calculator.java

package com.mashibing.inter;
​
public interface Calculator {
​
 public int add(int i,int j);
​
 public int sub(int i,int j);
​
 public int mult(int i,int j);
​
 public int div(int i,int j);
}

MyCalculator.java

package com.mashibing.inter;
​
public class MyCalculator implements Calculator {
 public int add(int i, int j) {
 int result = i + j;
 return result;
 }
​
 public int sub(int i, int j) {
 int result = i - j;
 return result;
 }
​
 public int mult(int i, int j) {
 int result = i * j;
 return result;
 }
​
 public int div(int i, int j) {
 int result = i / j;
 return result;
 }
}

MyTest.java

public class MyTest {
 public static void main(String[] args) throws SQLException {
 MyCalculator myCalculator = new MyCalculator();
 System.out.println(myCalculator.add(1, 2));
 }
}

此代码非常简单，就是基础的javase的代码实现，此时如果需要添加日志功能应该怎么做呢，只能在每个方法中添加日志输出，同时如果需要修改的话会变得非常麻烦。

MyCalculator.java

package com.mashibing.inter;
​
public class MyCalculator implements Calculator {
 public int add(int i, int j) {
 System.out.println("add 方法开始执行，参数为："+i+","+j);
 int result = i + j;
 System.out.println("add 方法开始完成结果为："+result);
 return result;
 }
​
 public int sub(int i, int j) {
 System.out.println("sub 方法开始执行，参数为："+i+","+j);
 int result = i - j;
 System.out.println("add 方法开始完成结果为："+result);
 return result;
 }
​
 public int mult(int i, int j) {
 System.out.println("mult 方法开始执行，参数为："+i+","+j);
 int result = i * j;
 System.out.println("add 方法开始完成结果为："+result);
 return result;
 }
​
 public int div(int i, int j) {
 System.out.println("div 方法开始执行，参数为："+i+","+j);
 int result = i / j;
 System.out.println("add 方法开始完成结果为："+result);
 return result;
 }
}

可以考虑将日志的处理抽象出来，变成工具类来进行实现：

LogUtil.java

package com.mashibing.util;
​
import java.util.Arrays;
​
public class LogUtil {
​
 public static void start(Object ... objects){
 System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
 }
​
 public static void stop(Object ... objects){
 System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
 }
}

MyCalculator.java

package com.mashibing.inter;
​
import com.mashibing.util.LogUtil;
​
public class MyCalculator implements Calculator {
 public int add(int i, int j) {
 LogUtil.start(i,j);
 int result = i + j;
 LogUtil.stop(result);
 return result;
 }
​
 public int sub(int i, int j) {
 LogUtil.start(i,j);
 int result = i - j;
 LogUtil.stop(result);
 return result;
 }
​
 public int mult(int i, int j) {
 LogUtil.start(i,j);
 int result = i * j;
 LogUtil.stop(result);
 return result;
 }
​
 public int div(int i, int j) {
 LogUtil.start(i,j);
 int result = i / j;
 LogUtil.stop(result);
 return result;
 }
}

按照上述方式抽象之后，代码确实简单很多，但是大家应该已经发现在输出的信息中并不包含具体的方法名称，我们更多的是想要在程序运行过程中动态的获取方法的名称及参数、结果等相关信息，此时可以通过使用动态代理的方式来进行实现。

CalculatorProxy.java

package com.mashibing.proxy;
​
import com.mashibing.inter.Calculator;
​
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
​
/**
 * 帮助Calculator生成代理对象的类
 */
public class CalculatorProxy {
​
 /**
 *
 *  为传入的参数对象创建一个动态代理对象
 * @param calculator 被代理对象
 * @return
 */
 public static Calculator getProxy(final Calculator calculator){
​
​
 //被代理对象的类加载器
 ClassLoader loader = calculator.getClass().getClassLoader();
 //被代理对象的接口
 Class[] interfaces = calculator.getClass().getInterfaces();
 //方法执行器，执行被代理对象的目标方法
 InvocationHandler h = new InvocationHandler() {
 /**
 *  执行目标方法
 * @param proxy 代理对象，给jdk使用，任何时候都不要操作此对象
 * @param method 当前将要执行的目标对象的方法
 * @param args 这个方法调用时外界传入的参数值
 * @return
 * @throws Throwable
 */
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 //利用反射执行目标方法,目标方法执行后的返回值
//                System.out.println("这是动态代理执行的方法");
 Object result = null;
 try {
 System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(args));
 result = method.invoke(calculator, args);
 System.out.println(method.getName()+"方法执行完成，结果是："+ result);
 } catch (Exception e) {
 System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
 } finally {
 System.out.println(method.getName()+"方法执行结束了......");
 }
 //将结果返回回去
 return result;
 }
 };
 Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
 return (Calculator) proxy;
 }
}

我们可以看到这种方式更加灵活，而且不需要在业务方法中添加额外的代码，这才是常用的方式。如果想追求完美的同学，还可以使用上述的日志工具类来完善。

LogUtil.java

package com.mashibing.util;
​
import java.lang.reflect.Method;
import java.util.Arrays;
​
public class LogUtil {
​
 public static void start(Method method, Object ... objects){
//        System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
 System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
 }
​
 public static void stop(Method method,Object ... objects){
//        System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
 System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
​
 }
​
 public static void logException(Method method,Exception e){
 System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
 }
 
 public static void end(Method method){
 System.out.println(method.getName()+"方法执行结束了......");
 }
}

CalculatorProxy.java

package com.mashibing.proxy;
​
import com.mashibing.inter.Calculator;
import com.mashibing.util.LogUtil;
​
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
​
/**
 * 帮助Calculator生成代理对象的类
 */
public class CalculatorProxy {
​
 /**
 *
 *  为传入的参数对象创建一个动态代理对象
 * @param calculator 被代理对象
 * @return
 */
 public static Calculator getProxy(final Calculator calculator){
​
​
 //被代理对象的类加载器
 ClassLoader loader = calculator.getClass().getClassLoader();
 //被代理对象的接口
 Class[] interfaces = calculator.getClass().getInterfaces();
 //方法执行器，执行被代理对象的目标方法
 InvocationHandler h = new InvocationHandler() {
 /**
 *  执行目标方法
 * @param proxy 代理对象，给jdk使用，任何时候都不要操作此对象
 * @param method 当前将要执行的目标对象的方法
 * @param args 这个方法调用时外界传入的参数值
 * @return
 * @throws Throwable
 */
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 //利用反射执行目标方法,目标方法执行后的返回值
//                System.out.println("这是动态代理执行的方法");
 Object result = null;
 try {
 LogUtil.start(method,args);
 result = method.invoke(calculator, args);
 LogUtil.stop(method,args);
 } catch (Exception e) {
 LogUtil.logException(method,e);
 } finally {
 LogUtil.end(method);
 }
 //将结果返回回去
 return result;
 }
 };
 Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
 return (Calculator) proxy;
 }
}

很多同学看到上述代码之后可能感觉已经非常完美了，但是要说明的是，这种动态代理的实现方式调用的是jdk的基本实现，如果需要代理的目标对象没有实现任何接口，那么是无法为他创建代理对象的，这也是致命的缺陷。而在Spring中我们可以不编写上述如此复杂的代码，只需要利用AOP，就能够轻轻松松实现上述功能，当然，Spring AOP的底层实现也依赖的是动态代理。

AOP的核心概念及术语

  • 切面（Aspect）: 指关注点模块化，这个关注点可能会横切多个对象。事务管理是企业级Java应用中有关横切关注点的例子。 在Spring AOP中，切面可以使用通用类基于模式的方式（schema-based approach）或者在普通类中以@Aspect注解（@AspectJ 注解方式）来实现。

  • 连接点（Join point）: 在程序执行过程中某个特定的点，例如某个方法调用的时间点或者处理异常的时间点。在Spring AOP中，一个连接点总是代表一个方法的执行。

  • 通知（Advice）: 在切面的某个特定的连接点上执行的动作。通知有多种类型，包括“around”, “before” and “after”等等。通知的类型将在后面的章节进行讨论。 许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链。

  • 切点（Pointcut）: 匹配连接点的断言。通知和切点表达式相关联，并在满足这个切点的连接点上运行（例如，当执行某个特定名称的方法时）。切点表达式如何和连接点匹配是AOP的核心：Spring默认使用AspectJ切点语义。

  • 引入（Introduction）: 声明额外的方法或者某个类型的字段。Spring允许引入新的接口（以及一个对应的实现）到任何被通知的对象上。例如，可以使用引入来使bean实现 IsModified接口， 以便简化缓存机制（在AspectJ社区，引入也被称为内部类型声明（inter））。

  • 目标对象（Target object）: 被一个或者多个切面所通知的对象。也被称作被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，那么这个对象永远是一个被代理（proxied）的对象。

  • AOP代理（AOP proxy）:AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。

  • 织入（Weaving）: 把切面连接到其它的应用程序类型或者对象上，并创建一个被被通知的对象的过程。这个过程可以在编译时（例如使用AspectJ编译器）、类加载时或运行时中完成。 Spring和其他纯Java AOP框架一样，是在运行时完成织入的。

AOP的通知类型

  • 前置通知（Before advice）: 在连接点之前运行但无法阻止执行流程进入连接点的通知（除非它引发异常）。

  • 后置返回通知（After returning advice）:在连接点正常完成后执行的通知（例如，当方法没有抛出任何异常并正常返回时）。

  • 后置异常通知（After throwing advice）: 在方法抛出异常退出时执行的通知。

  • 后置通知（总会执行）（After (finally) advice）: 当连接点退出的时候执行的通知（无论是正常返回还是异常退出）。

  • 环绕通知（Around Advice）:环绕连接点的通知，例如方法调用。这是最强大的一种通知类型，。环绕通知可以在方法调用前后完成自定义的行为。它可以选择是否继续执行连接点或直接返回自定义的返回值又或抛出异常将执行结束。

AOP的应用场景

  • 日志管理

  • 权限认证

  • 安全检查

  • 事务控制

2、Spring AOP的简单配置

在上述代码中我们是通过动态代理的方式实现日志功能的，但是比较麻烦，现在我们将要使用spring aop的功能实现此需求，其实通俗点说的话，就是把LogUtil的工具类换成另外一种实现方式。

1、添加pom依赖

 
 cglib
 cglib
 3.3.0
 
 
 
 org.aspectj
 aspectjweaver
 1.9.5
 
 
 
 aopalliance
 aopalliance
 1.0
 
 
 
 org.springframework
 spring-aspects
 5.2.3.RELEASE
2、编写配置

  • 将目标类和切面类加入到IOC容器中，在对应的类上添加组件注解

    
*   给LogUtil添加@Component注解
    
*   给MyCalculator添加@Service注解
    
*   添加自动扫描的配置

  • 设置程序中的切面类

    
*   在LogUtil.java中添加@Aspect注解

  • 设置切面类中的方法是什么时候在哪里执行

package com.mashibing.util;
    ​
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    ​
    import java.lang.reflect.Method;
    import java.util.Arrays;
    ​
    @Component
    @Aspect
    public class LogUtil {
    ​
     /*
     设置下面方法在什么时候运行
     @Before:在目标方法之前运行：前置通知
     @After:在目标方法之后运行：后置通知
     @AfterReturning:在目标方法正常返回之后：返回通知
     @AfterThrowing:在目标方法抛出异常后开始运行：异常通知
     @Around:环绕：环绕通知
    ​
     当编写完注解之后还需要设置在哪些方法上执行，使用表达式
     execution(访问修饰符  返回值类型 方法全称)
     */
     @Before("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
     public static void start(){
    //        System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
    //        System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
     System.out.println("方法开始执行，参数是：");
     }
    ​
     @AfterReturning("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
     public static void stop(){
    //        System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
    //        System.out.println(method.getName()+"方法执行结束，结果是："+ Arrays.asList(objects));
     System.out.println("方法执行完成，结果是：");
    ​
     }
    ​
     @AfterThrowing("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
     public static void logException(){
    //        System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
     System.out.println("方法出现异常：");
     }
    ​
     @After("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
     public static void end(){
    //        System.out.println(method.getName()+"方法执行结束了......");
     System.out.println("方法执行结束了......");
     }
    }

  • 开启基于注解的aop的功能
3、测试
MyTest.java

 import com.mashibing.inter.Calculator;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 public class MyTest {
 public static void main(String[] args){
 ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
 Calculator bean = context.getBean(Calculator.class);
 bean.add(1,1);
 }
}

spring AOP的动态代理方式是jdk自带的方式，容器中保存的组件是代理对象com.sun.proxy.$Proxy对象

4、通过cglib来创建代理对象
MyCalculator.java

package com.mashibing.inter;
​
import org.springframework.stereotype.Service;
​
@Service
public class MyCalculator {
 public int add(int i, int j) {
 int result = i + j;
 return result;
 }
​
 public int sub(int i, int j) {
 int result = i - j;
 return result;
 }
​
 public int mult(int i, int j) {
 int result = i * j;
 return result;
 }
​
 public int div(int i, int j) {
 int result = i / j;
 return result;
 }
}

MyTest.java

public class MyTest {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
        MyCalculator bean = context.getBean(MyCalculator.class);
        bean.add(1,1);
        System.out.println(bean);
        System.out.println(bean.getClass());
    }
}

可以通过cglib的方式来创建代理对象，此时不需要实现任何接口，代理对象是

class com.mashibing.inter.MyCalculator$$EnhancerBySpringCGLIB$$1f93b605类型

综上所述：在spring容器中，如果有接口，那么会使用jdk自带的动态代理，如果没有接口，那么会使用cglib的动态代理。动态代理的实现原理，后续会详细讲。

注意：
1、切入点表达式

在使用表达式的时候，除了之前的写法之外，还可以使用通配符的方式：

*：

1、匹配一个或者多个字符

execution( public int com.mashibing.inter.Myalculator.(int,int))

2、匹配任意一个参数，

execution( public int com.mashibing.inter.MyCalculator.(int,))

3、只能匹配一层路径，如果项目路径下有多层目录，那么*只能匹配一层路径

4、权限位置不能使用*，如果想表示全部权限，那么不写即可

execution( com.mashibing.inter.MyCalculator.(int,*))

..：

1、匹配多个参数，任意类型参数

execution( com.mashibing.inter.MyCalculator.(..))

2、匹配任意多层路径

execution( com.mashibing..MyCalculator.(..))

在写表达式的时候，可以有N多种写法，但是有一种最偷懒和最精确的方式：

最偷懒的方式：execution( (..)) 或者 execution( .*(..))

最精确的方式：execution( public int com.mashibing.inter.MyCalculator.add(int,int))

除此之外，在表达式中还支持 &&、||、！的方式

&&：两个表达式同时

execution( public int com.mashibing.inter.MyCalculator.(..)) && execution( .(int,int) )

||：任意满足一个表达式即可

execution( public int com.mashibing.inter.MyCalculator.(..)) && execution( .(int,int) )

！：只要不是这个位置都可以进行切入

&&：两个表达式同时

execution( public int com.mashibing.inter.MyCalculator.*(..))

2、通知方法的执行顺序

在之前的代码中通知的执行顺序：

1、正常执行：@Before--->@After--->@AfterReturning

2、异常执行：@Before--->@After--->@AfterThrowing

3、获取方法的详细信息

在上面的案例中，我们并没有获取Method的详细信息，例如方法名、参数列表等信息，想要获取的话其实非常简单，只需要添加JoinPoint参数即可。

LogUtil.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
public class LogUtil {
​
 @Before("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public static void start(JoinPoint joinPoint){
 Object[] args = joinPoint.getArgs();
 String name = joinPoint.getSignature().getName();
 System.out.println(name+"方法开始执行，参数是："+ Arrays.asList(args));
 }
​
 @AfterReturning("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public static void stop(JoinPoint joinPoint){
 String name = joinPoint.getSignature().getName();
 System.out.println(name+"方法执行完成，结果是：");
​
 }
​
 @AfterThrowing("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public static void logException(JoinPoint joinPoint){
 String name = joinPoint.getSignature().getName();
 System.out.println(name+"方法出现异常：");
 }
​
 @After("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public static void end(JoinPoint joinPoint){
 String name = joinPoint.getSignature().getName();
 System.out.println(name+"方法执行结束了......");
 }
}

刚刚只是获取了方法的信息，但是如果需要获取结果，还需要添加另外一个方法参数，并且告诉spring使用哪个参数来进行结果接收

LogUtil.java

 @AfterReturning(value = "execution( public int com.mashibing.inter.MyCalculator.*(int,int))",returning = "result")
 public static void stop(JoinPoint joinPoint,Object result){
 String name = joinPoint.getSignature().getName();
 System.out.println(name+"方法执行完成，结果是："+result);
​
 }

也可以通过相同的方式来获取异常的信息

LogUtil.java

    @AfterThrowing(value = "execution( public int com.mashibing.inter.MyCalculator.*(int,int))",throwing = "exception")
    public static void logException(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法出现异常："+exception);
    }
4、spring对通过方法的要求

spring对于通知方法的要求并不是很高，你可以任意改变方法的返回值和方法的访问修饰符，但是唯一不能修改的就是方法的参数，会出现参数绑定的错误，原因在于通知方法是spring利用反射调用的，每次方法调用得确定这个方法的参数的值。

LogUtil.java

    @After("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
    private int end(JoinPoint joinPoint,String aa){
//        System.out.println(method.getName()+"方法执行结束了......");
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行结束了......");
        return 0;
    }
5、表达式的抽取

如果在实际使用过程中，多个方法的表达式是一致的话，那么可以考虑将切入点表达式抽取出来：

a、随便生命一个没有实现的返回void的空方法

b、给方法上标注@Potintcut注解

package com.mashibing.util;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class LogUtil {
    
    @Pointcut("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
    public void myPoint(){}
    
    @Before("myPoint()")
    public static void start(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法开始执行，参数是："+ Arrays.asList(args));
    }

    @AfterReturning(value = "myPoint()",returning = "result")
    public static void stop(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完成，结果是："+result);

    }

    @AfterThrowing(value = "myPoint()",throwing = "exception")
    public static void logException(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法出现异常："+exception.getMessage());
    }

    @After("myPoint()")
    private int end(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行结束了......");
        return 0;
    }
}
6、环绕通知的使用
LogUtil.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
public class LogUtil {
 @Pointcut("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public void myPoint(){}
 
 /**
 * 环绕通知是spring中功能最强大的通知
 * @param proceedingJoinPoint
 * @return
 */
 @Around("myPoint()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
 Object[] args = proceedingJoinPoint.getArgs();
 String name = proceedingJoinPoint.getSignature().getName();
 Object proceed = null;
 try {
 System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
 //利用反射调用目标方法，就是method.invoke()
 proceed = proceedingJoinPoint.proceed(args);
 System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
 } catch (Throwable e) {
 System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
 }finally {
 System.out.println("环绕后置通知"+name+"方法结束");
 }
 return proceed;
 }
}

总结：环绕通知的执行顺序是优于普通通知的，具体的执行顺序如下：

环绕前置-->普通前置-->目标方法执行-->环绕正常结束/出现异常-->环绕后置-->普通后置-->普通返回或者异常。

但是需要注意的是，如果出现了异常，那么环绕通知会处理或者捕获异常，普通异常通知是接收不到的，因此最好的方式是在环绕异常通知中向外抛出异常。

7、多切面运行的顺序

如果有多个切面要进行执行，那么顺序是什么样的呢？

LogUtil.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
public class LogUtil {
 @Pointcut("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public void myPoint(){}
 @Before("myPoint()")
 public static void start(JoinPoint joinPoint){
//        System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
//        System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
 Object[] args = joinPoint.getArgs();
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法开始执行，参数是："+ Arrays.asList(args));
 }
​
 @AfterReturning(value = "myPoint()",returning = "result")
 public static void stop(JoinPoint joinPoint,Object result){
//        System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
//        System.out.println(method.getName()+"方法执行结束，结果是："+ Arrays.asList(objects));
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法执行完成，结果是："+result);
​
 }
​
 @AfterThrowing(value = "myPoint()",throwing = "exception")
 public static void logException(JoinPoint joinPoint,Exception exception){
//        System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法出现异常："+exception.getMessage());
 }
​
 @After("myPoint()")
 private int end(JoinPoint joinPoint){
//        System.out.println(method.getName()+"方法执行结束了......");
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法执行结束了......");
 return 0;
 }
​
 /**
 * 环绕通知是spring中功能最强大的通知
 * @param proceedingJoinPoint
 * @return
 */
 //@Around("myPoint()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
 Object[] args = proceedingJoinPoint.getArgs();
 String name = proceedingJoinPoint.getSignature().getName();
 Object proceed = null;
 try {
 System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
 //利用反射调用目标方法，就是method.invoke()
 proceed = proceedingJoinPoint.proceed(args);
 System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
 } catch (Throwable e) {
 System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
 }finally {
 System.out.println("环绕后置通知"+name+"方法结束");
 }
 return proceed;
 }
}

SecurityAspect.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
public class SecurityAspect {
​
 @Before("com.mashibing.util.LogUtil.myPoint()")
 public static void start(JoinPoint joinPoint){
 Object[] args = joinPoint.getArgs();
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法开始执行，参数是："+ Arrays.asList(args));
 }
​
 @AfterReturning(value = "com.mashibing.util.LogUtil.myPoint()",returning = "result")
 public static void stop(JoinPoint joinPoint,Object result){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法执行完成，结果是："+result);
​
 }
​
 @AfterThrowing(value = "com.mashibing.util.LogUtil.myPoint()",throwing = "exception")
 public static void logException(JoinPoint joinPoint,Exception exception){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法出现异常："+exception.getMessage());
 }
​
 @After("com.mashibing.util.LogUtil.myPoint()")
 private int end(JoinPoint joinPoint){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法执行结束了......");
 return 0;
 }
​
 /**
 * 环绕通知是spring中功能最强大的通知
 * @param proceedingJoinPoint
 * @return
 */
 //@Around("myPoint()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
 Object[] args = proceedingJoinPoint.getArgs();
 String name = proceedingJoinPoint.getSignature().getName();
 Object proceed = null;
 try {
 System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
 //利用反射调用目标方法，就是method.invoke()
 proceed = proceedingJoinPoint.proceed(args);
 System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
 } catch (Throwable e) {
 System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
 }finally {
 System.out.println("环绕后置通知"+name+"方法结束");
 }
 return proceed;
 }
}

在spring中，默认是按照切面名称的字典顺序进行执行的，但是如果想自己改变具体的执行顺序的话，可以使用@Order注解来解决，数值越小，优先级越高。

LogUtil.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
@Order(2)
public class LogUtil {
 @Pointcut("execution( public int com.mashibing.inter.MyCalculator.*(int,int))")
 public void myPoint(){}
 @Before("myPoint()")
 public static void start(JoinPoint joinPoint){
//        System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
//        System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
 Object[] args = joinPoint.getArgs();
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法开始执行，参数是："+ Arrays.asList(args));
 }
​
 @AfterReturning(value = "myPoint()",returning = "result")
 public static void stop(JoinPoint joinPoint,Object result){
//        System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
//        System.out.println(method.getName()+"方法执行结束，结果是："+ Arrays.asList(objects));
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法执行完成，结果是："+result);
​
 }
​
 @AfterThrowing(value = "myPoint()",throwing = "exception")
 public static void logException(JoinPoint joinPoint,Exception exception){
//        System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法出现异常："+exception.getMessage());
 }
​
 @After("myPoint()")
 private int end(JoinPoint joinPoint){
//        System.out.println(method.getName()+"方法执行结束了......");
 String name = joinPoint.getSignature().getName();
 System.out.println("Log:"+name+"方法执行结束了......");
 return 0;
 }
​
 /**
 * 环绕通知是spring中功能最强大的通知
 * @param proceedingJoinPoint
 * @return
 */
 //@Around("myPoint()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
 Object[] args = proceedingJoinPoint.getArgs();
 String name = proceedingJoinPoint.getSignature().getName();
 Object proceed = null;
 try {
 System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
 //利用反射调用目标方法，就是method.invoke()
 proceed = proceedingJoinPoint.proceed(args);
 System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
 } catch (Throwable e) {
 System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
 }finally {
 System.out.println("环绕后置通知"+name+"方法结束");
 }
 return proceed;
 }
}

SecurityAspect.java

package com.mashibing.util;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
import java.util.Arrays;
​
@Component
@Aspect
@Order(1)
public class SecurityAspect {
​
 @Before("com.mashibing.util.LogUtil.myPoint()")
 public static void start(JoinPoint joinPoint){
 Object[] args = joinPoint.getArgs();
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法开始执行，参数是："+ Arrays.asList(args));
 }
​
 @AfterReturning(value = "com.mashibing.util.LogUtil.myPoint()",returning = "result")
 public static void stop(JoinPoint joinPoint,Object result){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法执行完成，结果是："+result);
​
 }
​
 @AfterThrowing(value = "com.mashibing.util.LogUtil.myPoint()",throwing = "exception")
 public static void logException(JoinPoint joinPoint,Exception exception){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法出现异常："+exception.getMessage());
 }
​
 @After("com.mashibing.util.LogUtil.myPoint()")
 private int end(JoinPoint joinPoint){
 String name = joinPoint.getSignature().getName();
 System.out.println("Security:"+name+"方法执行结束了......");
 return 0;
 }
​
 /**
 * 环绕通知是spring中功能最强大的通知
 * @param proceedingJoinPoint
 * @return
 */
 //@Around("myPoint()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
 Object[] args = proceedingJoinPoint.getArgs();
 String name = proceedingJoinPoint.getSignature().getName();
 Object proceed = null;
 try {
 System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
 //利用反射调用目标方法，就是method.invoke()
 proceed = proceedingJoinPoint.proceed(args);
 System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
 } catch (Throwable e) {
 System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
 }finally {
 System.out.println("环绕后置通知"+name+"方法结束");
 }
 return proceed;
 }
}

如果需要添加环绕通知呢，具体的执行顺序又会是什么顺序呢？

因为环绕通知在进行添加的时候，是在切面层引入的，所以在哪个切面添加环绕通知，那么就会在哪个切面执行。

3、基于配置的AOP配置

之前我们讲解了基于注解的AOP配置方式，下面我们开始讲一下基于xml的配置方式，虽然在现在的企业级开发中使用注解的方式比较多，但是你不能不会，因此需要简单的进行配置，注解配置快速简单，配置的方式共呢个完善。

1、将所有的注解都进行删除

2、添加配置文件

aop.xml



​
 
 
​

你可能感兴趣的:(javaspring)

  • 【数据库学习】Flyway 兔兔西 数据库学习数据库学习之postgres数据库
    1，功能数据库版本管理；实现管理并跟踪数据库变更，支持数据库版本自动升级。2，使用1）java使用添加依赖org.flywaydbflyway-core6.5.7配置：javaspring:flyway:#是否启用enabled:true#可以支持多个location,用','隔开locations:classpath:db/migration#是否创建元数据表validate-on-migrat
  • Spring是怎样处理循环依赖的？ 后端开发萌新 死磕Spring源码系列springjava
    文章目录环境前言什么是循环依赖？所有注入场景的循环依赖Spring都能解决吗？场景TestA.javaTestB.javaspring-context.xmlMain.java测试结果Spring是怎么解决循环依赖的？前置说明源码解析addSingletonFactorygetSingletongetEarlyBeanReference总结环境SpringFrameworkVersion：5.3.
  • 【JavaSpring】为什么使用sring以及其中的bean线程安全吗？spring支持几种bean作用域和自动装配bean哪些方式？spring事务隔离？mvc运行流程 王果冻ddd 安全springmvcjava开发语言
    目录1、为什么要使用spring？2、spring中的bean是线程安全的吗？3、spring支持几种bean的作用域？4、spring自动装配bean有哪些方式？5、spring事务实现方式有哪些？6、说一下spring的事务隔离？7、说一下springmvc运行流程？1、为什么要使用spring？•spring提供ioc技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松
  • JavaSpring-AOP详解（Maven导入 深入浅出） GarsonW 软件开发springjava
    在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。目录通过Maven仓库导入相关依赖AOP（开始）AOP术语AOP五种通知AOP相同切入点的抽取有多个增强类对同一个同一个方法进行增强通过Maven仓库导入相关依赖文件结构：pom.xml:4.0.0comGarson
  • 85道Java Spring综合面试题详解含答案（值得珍藏） 孤蓬&听雨 面试资料javaspring开发语言面试
    点击下载《85道JavaSpring综合面试题详解含答案（值得珍藏）》1.Spring概述1.1什么是spring?Spring是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。1.2使用Spring框架的好处是什么？轻量：S
  • 深入理解Java Spring中的全局异常处理：以Reggie项目为例 hoypte javaspring状态模式
    在JavaSpring开发中，异常处理是非常关键的一部分。优雅地处理异常不仅可以提升用户体验，还能帮助开发者快速定位问题。本文将通过Reggie项目中的一个实例，深入探讨如何在Spring中使用@ControllerAdvice和@ExceptionHandler实现全局异常处理。项目背景Reggie是一个基于Spring框架的Web应用，它可能包含多个控制器（Controller）来处理不同的业
  • Java Spring注解——Controller层、Service层、mapper层 千Deng java开发语言
    目录前言一、Controller层常用注解（一）写在类名上方（二）写在类内部二、Service层常用注解三、mapper层常用注解四、lombok注解（一）用于实体类（二）用于类对象后续敬请期待前言JavaSpring注解——Controller层、Service层、mapper层等一、Controller层常用注解（一）写在类名上方@RestController@RestController可将
  • SpringBoot动态切换数据源 陆卿之 springboot后端java
    文章目录SpringBoot动态切换数据源数据库添加依赖配置数据源信息TestUser.javaTestUserMapper.java方式一（ThreadLocal）DynamicDataSourceContextHolder.javaDynamicRoutingDataSource.javaDynamicDataSourceConfig.javaTestController.javaSpring
  • Java Spring框架基础教程 C红毛丹 javaspring开发语言
    1.引言JavaSpring框架是一个轻量级的、开源的应用程序框架，用于开发Java应用程序。它提供了一种简化和加速Java应用程序开发的方式，同时也提供了一些强大的功能和特性。本教程将介绍JavaSpring框架的基础知识和使用方法，帮助读者快速上手并理解该框架的核心概念。2.Spring框架概述Spring框架由RodJohnson于2002年创建，最初是为了解决企业级应用程序开发中的一些常见
  • @Scheduled注解 定时任务讲解 蓝胖子不是胖子 springbootspring
    用于在JavaSpring框架中定时执行特定任务的注解@Scheduled，它能够指定方法在特定时间间隔或特定时间点执行。默认参数是cron，cron参数被用来定义一个Cron表达式，它代表了任务执行的时间规则参数如下Cron这是是一种时间表达式，用于表示定时任务的执行规则。在Spring中，@Scheduled注解的cron参数就是用来设置Cron表达式的。Cron表达式的基本格式为：secdo
  • Spring Boot Serverless 实战 | Serverless 应用的监控与调试 阿里云云栖号 云栖号技术分享springbootserverlessjava
    简介：SpringBoot是基于JavaSpring框架的套件，它预装了Spring的一系列组件，让开发者只需要很少的配置就可以创建独立运行的应用程序。在云原生的环境中，有大量的平台可以运行SpringBoot应用，例如虚拟机、容器等。但其中最有吸引力的，是以Serverless的方式运行SpringBoot应用。作者：西流SpringBoot是基于JavaSpring框架的套件，它预装了Spri
  • security登录实战 Stephen_CY666 java
    以下是一个基本的security登录实战代码示例，采用JavaSpring框架：配置security@Configuration@EnableWebSecuritypublicclassSecurityConfigextendsWebSecurityConfigurerAdapter{@AutowiredprivateUserDetailServiceImpluserDetailsService;
  • JavaSpring使用Quartz任务调度定时器 美渊科技 java
    Quartz任务调度是什么Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz是一个完全由Java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能，但就其简易形式看，你会发现它易用得简直让人受不了！摘自百度百科其实，他还是没有解释明白，我简单说一
  • Spring实战(第4版)pdf weixin_30619101 java开发工具后端
    下载地址：网盘下载Spring实战（第4版）是非常畅销的Spring图书也是国内读者极其熟悉的Spring经典图书之一，Javaweb开发从入门到精通，了解JavaSpring技术内幕。全球有超过100000的开发者使用本书来学习Spring中文版累计销售超10万册，畅销经典Spring技术图书，针对Spring4全新升级作者CraigWalls，SpringSource的软件开发人员，也是一位畅
  • 【主流技术】Redis 在 Spring 框架中的实践 手术刀呀
    前言在JavaSpring项目中，数据与远程数据库的频繁交互对服务器的内存消耗比较大，而Redis的特性可以有效解决这样的问题。Redis的几个特性：Redis以内存作为数据存储介质，读写数据的效率极高；Redis支持key-value等多种数据结构，提供字符串，哈希，列表，队列，集合结构直接存取于内存，可持久化（RDB和AOF）；支持主从模式，可以配置集群。下面，我将和大家一起学习分享Redis
  • [学习][笔记]设计模式（基于C/C++实现）＜八＞工厂模式 二进制怪兽 设计模式设计模式
    文章目录工厂模式简单工厂模式定义使用场景基本思路实例总结工厂方法模式定义使用场景基本思路实例总结抽象工厂模式定义使用场景基本思路实例总结工厂总结模板工厂模式定义使用场景基本思路实例总结产品注册模板类+单例工厂模板类定义使用场景基本思路实例总结对于javaSpring工厂模式思考总结工厂模式C++深入浅出工厂模式（初识篇）C++深入浅出工厂模式（进阶篇）这种类型的设计模式属于创建型模式，它提供了一种
  • Centos安装RabbitMQ，JavaSpring发送RabbitMQ延迟延时消息，JavaSpring消费RabbitMQ消息 胡子哥502 javaMQcentosrabbitmqjava延迟消息
    1，版本说明erlang和rabbitmq版本说明https://www.rabbitmq.com/which-erlang.html确认需要安装的mq版本以及对应的erlang版本。2，下载安装文件RabbitMQ下载地址：https://packagecloud.io/rabbitmq/rabbitmq-serverErlang下载地址：https://packagecloud.io/rabb
  • 【Javaspring学习笔记】动态代理 hwj729748198 JavaspringJavaspring学习笔记
    在学习Spring的时候，我们知道Spring主要有两大思想，一个是IOC，另一个就是AOP，对于IOC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制，所以本篇随笔就是对java的动态机制进行一个回顾。动态代理有两种方式：1、jdk动态代理是由java内
  • 从零开始认识并操纵Spring Aop事务 Automn
    [TOC]声明：从零开始，并不代表你对javaSpring一点都不懂的程度哈，本实例只是过一个概貌，详细内容会分多篇文章拆解业务介绍要想要设计一个和事务操作相关的业务，我们以最经典的转账的例子来描述转账，即两个用户之间钱的关系变动，但要求总和不变版本声明本案例使用的Web版本2.5，Spring版本为4.3开发工具为eclipse操作步骤导包Spring各版本官方包下载下载的包包含Spring包以
  • Spring源码：占位符${}解析源码分析 mumubili springPropertySource属性配置javaspringspringboot
    目录1.Spring中用到的占位符解析类2.PropertySourcesPlaceholderConfigurer实现bean工厂后处理器3.PropertyPlaceholderHelper帮助类解析逻辑在javaspring项目中，我们经常使用到${}占位符实现属性值的获取，最常见的就是使用@Value("${propsKey}")的方式完成bean属性值的注入，如下：@Value("${a
  • 基于JavaSpring的学生宿舍管理系统 柒月玖. Javajava
    点击以下链接获取源码：https://download.csdn.net/download/qq_64505944/88407844
  • Java Spring拦截器优化实践: 专注于API路径拦截 猫头虎 已解决的Bug专区Spring全家桶技术专区javaspring开发语言
    博主猫头虎带您GotoNewWorld.✨博客首页——猫头虎的博客《面试题大全专栏》文章图文并茂生动形象简单易学！欢迎大家来踩踩~《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~希望本文能够给您带来一定的帮助文章粗浅，敬请批评指正！文章目录JavaSpring拦截器优化实践:专注于API路径拦截摘要
  • 处理multipart形式的数据 losspm
    前言由于本人接触最多的是电子商城的开发，目前涉及到的接口数据处理最多的为字符串，少部分为图片，因此处理大型文件的经验比较少。在学习JavaSpring过程中，了解到JavaSpring处理数据过程中有很多值得学习的地方。就拿multipart来说，Spring为multipart提供了很多扩展性的配置，能够针对不同的业务场景进行相关配置multipart对于表单提交，multipart格式的数据会
  • golang工程——gRpc 拦截器及原理 咚伢 golang后端
    oauth2认证与拦截器类似javaspring中的拦截器。gRpc也有拦截器的说法，拦截器可作用于客户端请求，服务端请求。对请求进行拦截，进行业务上的一些封装校验等，类似一个中间件的作用拦截器类型一元请求拦截器流式请求拦截器链式拦截器（一个个调用对应处理函数）使用场景：拦截器可以从元数据获取一些认证进行进行校验。服务端拦截器拦截器定义interceptor.gopackageserverimpo
  • layui+java spring 实现图片文件新增到数据库 Luffe船长 javalayuispring
    项目场景：layui+javaspring实现图片文件新增到数据库解决方案：1.首先layui是个不再更新的网址有想了解的可以浏览官网表格组件table-Layui文档2.官网内有专门的组件代码直接粘过来即可Demo单图片上传多图片上传预览图：layui.use(function(){varupload=layui.upload;varlayer=layui.layer;varelement=la
  • 你真的需要微服务? whyreal
    原文我们已经设计和构建了十多年的软件，大部分时间我们一直在使用优秀的Symfony框架来实现这一目标。Symfony是一个传统的PHP组件集，受JavaSpring的启发，我们发现它非常适合作为我们的企业Web应用程序和数字产品的快速开发。然而，去年发布的Symfony4代表了该框架的重点逐渐变化;趋向于微服务方法，这种方法在过去几年中越来越受欢迎。为了说明这种转变，新版本宣称“微服务优先”，Sy
  • 【JavaSpring】Aop的通知类型，获取数据 岩塘 JavaSpringjava前端开发语言
    AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置前置通知@Pointcut("execution(voidorg.example.dao.BookDao.update())")privatevoidpt(){}@Before("pt()")publicvoidbefore(){System.out.println("beforeadvice");}后
  • 【JavaSpring】Aop案例 岩塘 java开发语言
    测定接口执行效率描述：在接口执行前输出当前系统时间开发模式：XMLor注解思路分析：1.导入坐标（pom.xml）org.aspectjaspectjweaver1.9.4org.springframeworkspring-context5.2.25.RELEASEjunitjunit3.8.1test2.制作连接点的方法（原始操作）packageorg.example.dao;publicint
  • 【JavaSpring】Aop切入点表达式 岩塘 java开发语言
    语法格式切入点：要进行增强的方法切入点表达式：要进行增强的方法的描述方式标准格式：动作关键词（访问修饰符【可省略】返回值包名.类名.方法名（参数）异常名【可省略】）描述方法一（描述接口）execution("execution(voidorg.example.dao.BookDao.update())")描述方法二（描述实现类）execution("execution(voidorg.exampl
  • 计算机专业毕业设计项目推荐06-工作室管理系统（Java+Vue+Mysql） 一个小肥羊 课程设计javavue.js
    工作室管理系统（JavaSpring+Vue+Mysql）**介绍****系统总体开发情况-功能模块****各部分模块实现****最后想说的****联系方式**介绍本系列(后期可能博主会统一为专栏)博文献给即将毕业的计算机专业同学们,因为博主自身本科和硕士也是科班出生,所以也比较了解计算机专业的毕业设计流程以及模式，在编写的过程中可以说几乎是参照毕业设计目录样式来进行的.博主分享的基本都是自己接触
  • java类加载顺序 3213213333332132 java
    package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
  • Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
  • php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
  • DOM改变字体大小 周华华 前端
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • c3p0的配置 g21121 c3p0
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
  • Java获取工程路径的几种方法 510888780 java
    第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
  • 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
    1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
  • Java新手入门的30个基本概念一 aijuans javajava 入门新手
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
  • Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
    1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
  • 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
      视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
  • Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
  • 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
    /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
  • 【Log4j一】Log4j总体介绍 bit1129 log4j
    Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
  • Java IO笔记 白糖_ java
    public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
  • Docker 监控 ronin47 docker监控
             目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
  • java-顺时针打印图形 bylijinnan java
    一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
  • 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
  • [并行计算]论宇宙的可计算性 comsci 并行计算
          现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
  • 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
  • JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
    怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
  • 未选之路 dcj3sjt126com 诗
    作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
  • Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
      15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
  • Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
  • 8个最佳Web开发资源推荐 lampcy 编程Web程序员
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
  • 架构师之面试------jdk的hashMap实现 nannan408 HashMap
    1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
  • html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
  • POJO和JavaBean的区别和联系 tjmljw POJOjava beans
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
  • java中单例的五种写法 liuxiaoling java单例
    /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他