「java面向切面编程」java面向切面编程 切面

今天给各位分享java面向切面编程的知识，其中也会对java面向切面编程 切面进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java里的sprint框架该怎么理解呢，我一直不明白
• 2、Java核心技术：Spring是什么？
• 3、java切面编程是什么设计模式
• 4、使用java语言,如何对一个类中的静态方法做切面编程?
• 5、Java编程中的AOP和IOC分别是什么呢，什么时候用呢

java里的sprint框架该怎么理解呢，我一直不明白

sping主要实现两个方面的东西

1、IOC控制翻转，就是在写程序的时候主张编程到接口，多写一些接口其它类来实现这个接口，易于扩展、重用、和维护

2、AOP面向切面编程，说白了就是不改动一个类文件本身，为这个类文件增加一些功能，如为一个类文件增加日志输出。

在有一些就是spring本身或和其它框架结合提供了一些方法，如spring的JDBC

Java核心技术：Spring是什么？

从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring就是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 下面从整体上认识一下Spring的主要特征： *轻量：从大小与开销两方面而言Spring都是轻量的。此外，Spring是非侵入式的：使用Spring,我们的类还是pojo类，完全不用继承和实现Spring的类和接口等。 也就是说，使用Spring的应用中的对象不依赖于Spring的特定类。 *IoC:Spring通过控制反转技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。可以认为IoC与JNDI相反--不是我们自己控制对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它，这就是DI--依赖注入。 基本上就是对象不用自己动手管理和创建。完全由容器管理，我们只管用就行。 *AOP:Spring提供了面向切面的编程支持，AOP将与程序业务无关的内容分离提取，应用对象只实现它们应该做的--完成业务逻辑--仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。 AOP将与业务无关的逻辑横切进真正的逻辑中。 *框架：Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），而用户就有更多的时间和精力去开发应用逻辑。 所有Spring的这些特征都能帮助我们够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。 *借助Spring,荣国依赖注入，AOP应用，面向接口编程，来降低业务组件之间的耦合度，增强系统的扩展性。 * 让已有的技术和框架更加易用。 *利用其对hibernate的SessionFactory、事务管理的封装，更简洁的应用hibernate. *Spring并不完全依赖于Spring,开发者可自由选用Spring框架的部分或全部 *利用AOP思想，集中处理业务逻辑，减少重复代码，构建优雅的解决方案。 *低侵入式设计，代码污染极低。 Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的"一站式"选择，并贯穿表现层、业务层及持久层。 虽然Spring可以一站式解决整个项目问题，但是Spring并不想取代那些已有的框架，而是与它们无缝地整合。Spring可以降低各种框架的使用难度，他提供了对各种优秀框架（如Struts、Hibernate、Hessian、Quartz等）的直接支持。 使用Spring的主要目的是使J2EE易用和促进好的编程习惯，Spring的目标就是让已有的技术更加易用。 所以Spring的一个重要思想就是整合和兼容。

java切面编程是什么设计模式

面向切面编程(也叫面向方面)：Aspect Oriented Programming(AOP),是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面（方面）编程。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

使用java语言,如何对一个类中的静态方法做切面编程?

package com.classloader.test;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

public class AOPCallStaticMehtod {

private CallBack callBack;

public AOPCallStaticMehtod(CallBack callBack) {

this.callBack = callBack;

}

public static interface CallBack {

void before(Method method);

void after(Method method, Object result);

}

@SuppressWarnings({ "unchecked", "rawtypes" })

public Object callMethod(Class clazz, String methodName, Class[] parameterTypes, Object[] parameters) {

Object result = null;

try {

Method method = null;

if (parameterTypes == null || parameterTypes.length == 0) {

method = clazz.getMethod(methodName);

if (Modifier.isStatic(method.getModifiers())) {

callBack.before(method);

result = method.invoke(null);

callBack.after(method, result);

}else{

System.out.println("这不是一个静态方法");

}

} else {

method = clazz.getMethod(methodName, parameterTypes);

if (Modifier.isStatic(method.getModifiers())) {

callBack.before(method);

result = method.invoke(null, parameters);

callBack.after(method, result);

}else{

System.out.println("这不是一个静态方法");

}

}

} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException

| InvocationTargetException e) {

if (e instanceof NoSuchMethodException) {

System.out.println("没有这个方法");

} else {

System.out.println("call is error!");

}

}

return result;

}

public static void main(String[] args) {

CallBack callBack = new CallBack() {

@Override

public void before(Method method) {

if(method.getName().equals("test1") || method.getName().equals("test2")){

System.out.println(method.getName() + "方法在调用之前被拦截，可以在这里切面编程");

}

}

@Override

public void after(Method method, Object result) {

if(method.getName().equals("test1") || method.getName().equals("test2")){

System.out.println(method.getName() + "方法调用以后被拦截，可以在这里切面编程");

System.out.println(method.getName() + "执行结果是：" + result);

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

}

}

};

AOPCallStaticMehtod AOPCallStaticMehtod = new AOPCallStaticMehtod(callBack);

AOPCallStaticMehtod.callMethod(Test.class, "test1", new Class[] { String.class }, new Object[] { "ppppppppppp" });

AOPCallStaticMehtod.callMethod(Test.class, "test2", null, null);

}

}

class Test {

public static void test1(String aa) {

System.out.println(aa);

}

public static String test2() {

System.out.println("fffffffffffffffff");

return "test2 result";

}

}

Java编程中的AOP和IOC分别是什么呢，什么时候用呢

控制反转（IOC）

（理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”）

1、Ioc—Inversion of Control：即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

2、谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象即由Ioc容器来控制对象的创建。

   谁控制谁？当然是IoC 容器控制了对象。

   控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

3、为何是反转，哪些方面反转了： 有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象。

  为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象,所以是反转。

哪些方面反转了？依赖对象的获取被反转了。     

      还是不明白没事，下面搞个简单案例来说就懂啦 ！！！

      例子：当我们在任何一个有实际开发意义的程序项目中，我们会使用很多类来描述他们特有的功能，并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候，每个类都需要负责管理与自己有交互的类的引用和依赖，代码将会变的异常难以维护和极高的高耦合。而IOC的出现正是用来解决这个问题，我们通过IOC将这些依赖对象的创建、协调工作交给spring容器去处理，每个对象值需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看，获得依赖的对象的方式，进行了反转，变成了由spring容器控制对象如何获取外部资源（包括其他对象和文件资料等）。

总的来说：IOC就是通过在Xml配置文件里依赖注入来解决代码问题。

IOC的注入类型有几种？主要可以划分为三种：构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入

面向切面（AOP）

（面向切面编程，AOP其实只是OOP的补充而已，AOP基本上是通过代理机制实现的。）

        我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。   

         我们都知道 Java 是 OOP-面向对象编程的，它有自己的优势，也有自己的不足。比如说：在我们开发中，都会有一条业务主线（即客户的需求）。而我们要做的就是实现这个主线上的需求。我们在实现这些功能的时候，经常要干一些额外的不可避免的事情，比如事务的管理，日志的记录等，就很繁杂且代码量增多，所以 Spring 提供了另一种角度来思考程序结构，也就是把这一些事情剥离出来，然后适时适地的把它们加入到我们的代码中，比如说 声明式事务管理的时候，我们在 service 层检测到save*、update*这些方法要被调用的时候，我们先进行开启事务什么的，这就是AOP，面向编程的思想。

      AOP的术语：

         1、通知（Advice）：就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下

         2、连接点（JoinPoint）：这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

         3、切入点（Pointcut）：上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

         4、切面（Aspect）：切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

         5、引入（introduction）：允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

         6、目标（target）：引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

         7、代理（proxy）：怎么实现整套aop机制的，都是通过代理，这个一会给细说。

         8、织入（weaving）：把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

java面向切面编程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java面向切面编程 切面、java面向切面编程的信息别忘了在本站进行查找喔。