开发日常小结（19）：Spring AOP 最佳入门试验 + 游戏禁言的应用实例小结

最新推荐文章于 2024-06-14 22:19:44 发布

后台技术汇

最新推荐文章于 2024-06-14 22:19:44 发布

阅读量371

点赞数

CC 4.0 BY-SA版权

分类专栏：后台工作总结 Java Spring+SpringMVC+Mybatis，项目实战 Java基础与积累

本文链接：https://blog.youkuaiyun.com/qq_29166327/article/details/80367974

Spring+SpringMVC+Mybatis，项目实战同时被 3 个专栏收录

125 篇文章

订阅专栏

Java

66 篇文章

订阅专栏

Java基础与积累

66 篇文章

订阅专栏

本文介绍了一种利用AOP技术优化游戏中的玩家发言禁言功能的方法。通过在发言接口前后增加切面处理，实现对玩家发言权限的统一管理，减少代码冗余。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2018年5月18日18:08:27

一、实例-业务需求和场景：

1、游戏的玩家时常出言不逊，这时候禁言这个功能应运而生了；2、手游的发言场景，其实是前端到后端的接口调用与返回的过程；3、特别是棋牌游戏，德州扑克有聊天接口、斗地主、百人场等等都会有相应的接口；

因次，导致的结果是：禁言就是不断地在游戏接口重复判断，这样的工作是重复性的。有没有好的方法捏？下面讲解一下我在工作的一次小突破（实际结果嘛··文末在揭晓）

二、分析需求

解决办法：在实际的接口调用前后，可以对接口进行切面处理：使用环绕增强，当发言接口(sendPlayerMsg)被调用时，将会被aop捕捉到，在切面方法中执行（1）判断禁言结果（2）执行发言接口并获取到返回值（3）修改返回值（4）response给前端。【详细项目代码无法粘贴，但是思路就是这样，下面提供Demo进行入门】

三、AOP 最佳入门试验

3.1 几句话概括aop的环绕增强

1）环绕就是aop方法类的method，会包含被切接口（这里是发言接口sendPlayerMsg）的执行；

2）活用ProceedingJoinPoint类，选择性的获取被切接口的修饰、返回值、函数名、参数列表，并可以控制是否执行被切接口；

3.2 Demo

1）xml配置（applicationContext.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"
    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.xsd">
        <!-- 1.创建目标对象 -->
        <bean id="userDao" class="UserDao"></bean>
        <!-- 2.创建切面类对象 -->
        <bean id="myaspect" class="MyAspect"></bean>
        <!-- 3.配置切面 -->
        <aop:config>
            <!--  切面 ref:关联切面类对象 	-->
            <aop:aspect ref="myaspect">
               <!--
                   3.1切入点
                   id：切入点的别名
                   expression: 切入点表达式 ：格式： execution(方法的返回值类型 方法名(包+类 ..:表示零个或一个以上)（方法中参数列表）)
                -->
				<aop:pointcut expression="execution(* UserDao.*(..))" id="myspt"/>
              <!-- 3.2通知 -->
              <!-- 前置通知
                   method：切面类中的前置通知的方法名称
                   point-ref：需要关联的切入点
               -->
               <aop:before method="before" pointcut-ref="myspt"/>
               <aop:after method="after" pointcut-ref="myspt"/>
               <aop:around method="round" pointcut-ref="myspt"/>
            </aop:aspect>
		</aop:config>
</beans>

2）切面类和切面处理方法

import java.lang.reflect.Modifier;
import java.util.Arrays;
import javax.management.InstanceAlreadyExistsException;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect  {
    /**
     * 常用的通知类：
     *   前置通知： 在目标对象的连接点之前调用
     *   后置通知：在目标对象的连接点之后调用
     *   环绕通知： 在目标对象的连接点之前与之后调用
     */
    
    //定义前置通知
    public void before(){
             System.out.println("开启事务");
    }
    //定义后置通知
    public void after(){
             System.out.println("结束事务");
    }
    //环绕通知
    public void round(ProceedingJoinPoint jp) throws Throwable{
             System.out.println("环绕通知前面代码");
             Object proceed = null;
             //执行目标对象的核心方法
             proceed = jp.proceed(); //执行连接点方法 (userDao.save / userDao.update)
             
             System.out.println("proceed: "+proceed	);
             
             System.out.println("-----------0-----------");
             
             System.out.println(jp.getSignature()); //void UserDao.save()
             System.out.println(jp.getSignature().getName()); 	//save
             System.out.println(jp.getSignature().getDeclaringTypeName()); 	//UserDao
             
             System.out.println("-----------1-----------");
             
             System.out.println(jp.getArgs());
             System.out.println(Arrays.toString(jp.getArgs()));
             System.out.println(jp.getTarget());
             
             System.out.println("------------2----------");
             System.out.println("目标方法名为:" + jp.getSignature().getName());
             System.out.println("目标方法所属类的简单类名:" + jp.getSignature().getDeclaringType().getSimpleName());
             System.out.println("目标方法所属类的类名:" + jp.getSignature().getDeclaringTypeName());
             System.out.println("目标方法声明类型:" + Modifier.toString(jp.getSignature().getModifiers()));
             //获取传入目标方法的参数
             Object[] args = jp.getArgs();
             for (int i = 0; i < args.length; i++) {
                 System.out.println("第" + (i+1) + "个参数为:" + args[i]);
             }
             System.out.println("环绕通知后面代码");
    }
    
}

3）被切函数（即：切入点、切入对象）

public class UserDao {
	private int a = 100;
	
	public int save(int a ){
		System.out.println("userDao.save "+ a);
		return a;
	}
	
	public int update(People p){
		System.out.println("userDao.update "+ p.toString());
		return p.getAge();
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}

	@Override
	public String toString() {
		return "UserDao [a=" + a + "]";
	}
	
}

4）DemoTest

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	        UserDao userDao = (UserDao)ac.getBean("userDao");
	        People p = new People(24,"aa");
	        userDao.save(100);
	        userDao.update(p);
	}
}

people类：

public class People {
	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public People(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "People [age=" + age + ", name=" + name + "]";
	}
	
}

5）测试结果：

开启事务
环绕通知前面代码
userDao.save 100
proceed: 100
-----------0-----------
int UserDao.save(int)
save
UserDao
-----------1-----------
[Ljava.lang.Object;@75edcb1f
[100]
UserDao [a=100]
------------2----------
目标方法名为:save
目标方法所属类的简单类名:UserDao
目标方法所属类的类名:UserDao
目标方法声明类型:public
第1个参数为:100
环绕通知后面代码
结束事务

五、参考blog

1.https://blog.youkuaiyun.com/gwblue/article/details/40592117

2.https://blog.youkuaiyun.com/qq924862077/article/details/74935882

3.https://blog.youkuaiyun.com/u010771890/article/details/54233750

4.https://blog.youkuaiyun.com/qq924862077/article/details/74935882

5.https://blog.youkuaiyun.com/tingzhiyi/article/details/52132644

6.https://blog.youkuaiyun.com/starjuly/article/details/52390208

六、现实结果

aop用于游戏确实可以减少某些代码的耦合度，但是接口这种东西实打实的，当以最安全和稳妥的做法；同时，由于大佬认为aop将请求全部拦截了，实际上并没有解决耦合度的矛盾；因次不推荐应用。