Java中的AOP

AOP编程是面向切面编程,说白了,一段代码的执行归根结底是方法的执行,当一个系统写好之后,往往需要新的功能或者添加一些新的操作,这些新的功能又是一些方法,这些方法需要嵌入到原来的系统中,让他们在系统原有方法的执行前或者后等等位置执行,这个时候,有两种方案,修改原来的代码,违背了OCP,方案二,使用AOP;

AOP编程就是在程序的执行过程中找到一些切入点,嵌入一些新的方法,以改变程序原来的执行过程,宏观上看,程序的功能变强大了。

Java语言中AOP是用JDK动态代理技术来实现的:代码

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface IUserBean {
public void getUser();
public void addUser();
public void updateUser();
public void deleteUser();
}

class UserBean implements IUserBean {
private String username = null;
public UserBean() {
}
public UserBean(String username) {
this.username = username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUsername()
{
return this.username;
}


public void addUser() {
System.out.println("this is addUser() method!");
}
public void deleteUser() {
System.out.println("this is deleteUser() method!");
}
public void getUser() {
System.out.println("this is getUser() method!");
}
public void updateUser() {
System.out.println("this is updateUser() method!");
}
}
[color=red]class JDKProxy implements InvocationHandler {
private Object targetObject;
public Object createProxyObject(Object targetObject)
{
this.targetObject=targetObject;
return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

UserBean userBean = (UserBean) targetObject;
String userName = userBean.getUsername();

//权限判断
if(userName!=null && !"".equals(userName)) {
//调用目标对象的方法
return method.invoke(targetObject, args);
}
else return null;
}
}[/color]

public class Demo{
public static void main(String[] args) {
JDKProxy jProxy = new JDKProxy();
// IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean(""));
IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean("aaa"));
userBean.addUser();
userBean.updateUser();
userBean.deleteUser();
userBean.getUser();

}
}


可以看到,JDK动态代理模式其实就是使用了代理模式,创建了一个代理对象。

这个代理对象将原来的方法周围及嵌入了一些新方法,其余代理模式唯一的区别是,代理模式直接覆盖接口的方法,而jdk动态代理中使用了反射技术,仅仅需要覆盖InvokerHandler接口的invoke方法。

但是JDK动态代理仅仅对实现接口的那些类支持AOP编程,对于不实现接口的那些类则无能为力。为了解决这个问题我们使用CGLIG的代理技术,

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
class UserBean {
private String username = null;
public UserBean() {
}
public UserBean(String username) {
this.username = username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUsername()
{
return this.username;
}

public void addUser() {
System.out.println("this is addUser() method!");
}
public void deleteUser() {
System.out.println("this is deleteUser() method!");
}
public void getUser() {
System.out.println("this is getUser() method!");
}
public void updateUser() {
System.out.println("this is updateUser() method!");
}
}


class CGLibProxy implements MethodInterceptor {

private Object targetObject;
public Object createProxyObject(Object targetObject) {
this.targetObject = targetObject;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.targetObject.getClass()); //非final 进行覆盖
enhancer.setCallback(this); //回调,通过
return enhancer.create(); //创建代理对象
}

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
UserBean userBean = (UserBean) targetObject;
String userName = userBean.getUsername();
Object result = null;
if(userName!=null && !"".equals(userName)) {
//调用目标对象的方法
return methodProxy.invoke(targetObject, args);
}
else return null;
}
}


public class Demo{
public static void main(String[] args) {
CGLibProxy cProxy = new CGLibProxy();
// UserBean userBean = (UserBean) jProxy.createProxyObject(new UserBean(""));
UserBean userBean = (UserBean) cProxy.createProxyObject(new UserBean("aaa"));
userBean.addUser();
userBean.updateUser();
userBean.deleteUser();
userBean.getUser();

}
}




Spring的AOP技术就是基于这两个技术实现的。
OpenMP 和 MPI 是两种不同的并行编程模型,可以在混合编程中一起使用。 在混合编程中,OpenMP 通常用于在单个节点上并行化程序的部分,而 MPI 用于在不同节点之间传递数据和进行通信。通过这种方式,可以利用多个节点和多个 CPU 核心的优势来加速程序的执行。 下面是一个简单的混合 OpenMP 和 MPI 编程的示例: ```c #include <mpi.h> #include <omp.h> #include <stdio.h> int main(int argc, char *argv[]) { int rank, size, thread_id, num_threads; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #pragma omp parallel private(thread_id, num_threads) { thread_id = omp_get_thread_num(); num_threads = omp_get_num_threads(); printf("Hello from thread %d of %d on process %d of %d\n", thread_id, num_threads, rank, size); } MPI_Finalize(); return 0; } ``` 在此示例中,我们使用 OpenMP 并行化 `printf` 语句,并使用 MPI 进行进程间通信。在每个进程上,我们使用 `omp_get_thread_num()` 和 `omp_get_num_threads()` 获取线程 ID 和线程总数,并将它们打印出来。 要编译此程序,您需要使用类似以下命令的编译器指令: ``` mpicc -fopenmp hybrid_mpi_openmp.c -o hybrid_mpi_openmp ``` 在运行程序时,您需要使用类似以下命令的命令: ``` mpirun -np 4 ./hybrid_mpi_openmp ``` 在此示例中,我们将使用 4 个进程运行程序。您可以将 `-np` 参数更改为所需的进程数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值