Spring的AOP编程

最新推荐文章于 2016-06-25 00:00:09 发布
最新推荐文章于 2016-06-25 00:00:09 发布
阅读量2k 收藏
点赞数
分类专栏： Spring 文章标签： Spring的AOP编程 动态代理 注解方式实现AOP编程 切入点表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x1164077611/article/details/51756389
版权

Spring的AOP编程

代理模式

概述

代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。

举例：明星（邓紫棋）<---经纪人<-------用户
-------------------目标-------（代理）

image

静态代理

静态代理，

  1. 代理对象，要实现与目标对象一样的接口；
  2. 举例
// 接口
public interface UserService {
	void deleteUser();
}

// 实现类
public class UserServiceImpl implements UserService{
	@Override
	public void deleteUser() {
		System.out.println(">> 删除一个User <<");
	}
}

// 实现类的代理对象
public class UserServiceImplProxy implements UserService {
	private UserService realUserService;
	public UserServiceImplProxy(UserService realUserService) {
		this.realUserService = realUserService;
	}
	@Override
	public void deleteUser() {
		System.out.println("== 开始执行操作 ==");
		realUserService.deleteUser();
		System.out.println("== 操作执行完毕 ==");
	}
}

总结：

  1. 静态代理在使用时，需要定义接口或是父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
  2. 静态代理存在一个问题：当我们在被代理的类中增加了一个方法，代理类中也要增加相应方法。

动态代理

// 做日志的JDK动态代理对象
public class LogJdkProxy implements InvocationHandler {
	private Object target; // 代理的目标对象
	public LogJdkProxy(Object target) {
		this.target = target;
	}
	/** 创建代理对象 */
	public Object createProxyInstance() {
// 第1个参数设置代码使用的类装载器，一般采用跟目标类相同的类装载器
		// 第2个参数设置代理类实现的接口
		// 第3个参数设置回调对象，当代理对象的方法被调用时，会调用该参数指定对象的invoke方法
		return Proxy.newProxyInstance(//
				getClass().getClassLoader(), // 第1个参数
				target.getClass().getInterfaces(), // 第2个参数
				this); // 第3个参数
	}
	/**
	 * @param proxy  目标对象的代理类实例
	 * @param method 对应于在代理实例上调用接口方法的Method实例
	 * @param args   传入到代理实例上方法参数值的对象数组
	 * @return 方法的返回值，没有返回值（void）时是null
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("== Log:开始执行操作，方法名："+method.getName()+" ==");
		Object result = method.invoke(target, args); // 执行原方法，把方法调用委派给目标对象
		System.out.println("== Log:操作执行完毕 ==");
		return result;
	}
}

JDK动态代理总结：

  1. JAVA动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口这两个来完成的。
  2. 要使用JDK动态代理，必须要定义接口。
  3. JDK动态代理将会拦截所有pubic的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。
  4. 如果只想拦截一部分方法，可以在invoke方法中对要执行的方法名进行判断。

使用CGLIB生成代理

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。 CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。 CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

  • 原对象：
// 此类不能是final的，否则不能有子类，CGLIB也就不能工作了
public class UserServiceImpl {

	// 这是final的方法，不能被子类重写，所以CGLIB不会拦截这个方法
	public final void foo1() {
		System.out.println(">> final的方法 <<");
	}

	// 这是static的方法，CGLIB不会拦截这个方法
	public static void foo2() {
		System.out.println(">> static的方法 <<");
	}

	// 这是private的方法，CGLIB不会拦截这个方法
	private void foo3() {
		System.out.println(">> private的方法 <<");
	}

	// CGLIB会拦截这个方法，可以是public, protected, default的修饰符
	public void deleteUser() {
		System.out.println(">> 删除一个User <<");
	}
}
  • CGLIB代理类
// CGLIB代理类
public class LogCglibProxy implements MethodInterceptor {
	private Object target; // 代理的目标对象
	/**
	 * 创建代理对象
	 * @param <T>
	 * @param target 目标对象
	 */
	public <T> T createProxyInstance(T target) {
		this.target = target;
		Enhancer enhancer = new Enhancer(); // 该类用于生成代理对象
		enhancer.setSuperclass(target.getClass()); // 设置父类
		enhancer.setCallback(this); // 设置回调对象为自己这个对象
		return (T) enhancer.create(); // 创建代理对象并返回
	}
	/**
	 * @param proxy 		 目标对象代理类的实例
	 * @param method		代理类实例上调用父类方法的Method实例
	 * @param args 			传入到方法参数值的对象数组
	 * @param methodProxy 	使用它调用父类的方法
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, 
MethodProxy methodProxy)	throws Throwable {
		System.out.println(proxy.getClass());
		System.out.println("== Log:开始执行操作，方法名：" + method.getName() + " ==");
		Object result = methodProxy.invoke(target, args); // 执行原方法
		System.out.println("== Log:操作执行完毕 ==");
		return result;
	}
}

CGLIB代理总结：

  1. CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。
  2. 要求类不能是final的，要拦截的方法要是非final、非static、非private的。

AOP

手动实现AOP

AOP 面向切面的编程，

AOP可以实现“业务代码”与“关注点代码”分离

// 保存一个用户
public void add(User user) { 
		Session session = null; 
		Transaction trans = null; 
		try { 
			session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
			trans = session.beginTransaction();    // 【关注点代码】
			 
			session.save(user);     // 核心业务代码
			 
			trans.commit();     //…【关注点代码】

		} catch (Exception e) {     
			e.printStackTrace(); 
			if(trans != null){ 
				trans.rollback();   //..【关注点代码】

			} 
		} finally{ 
			HibernateSessionFactoryUtils.closeSession(session);   ..【关注点代码】

		} 
   }

分析总结：

关注点代码，就是指重复执行的代码。

业务代码与关注点代码分离，好处？

  • 关注点代码写一次即可；
  • 开发者只需要关注核心业务；
  • 运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】

在Spring中进行AOP编程的基础

  • Aspect(切面)：

指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面是横切性关注点的抽象.

  • joinpoint(连接点)：

所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

  • Pointcut(切入点)：

所谓切入点是指我们要对那些joinpoint进行拦截的定义.

  • Advice(通知)：

所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

  • Target(目标对象)：

代理的目标对象

  • Weave(织入)：

指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

  • Introduction(引入)：

在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

  • 概念：Pointcut（切入点）

切入点Pointcout，就是指要指定一个规则，以表示要拦截哪些方法。切入点都是Pointcut接口的实现类。

所有切点都是Pointcut接口（切点）的实现类。经常使用的实现类如下：

• JdkRegexpMethodPointcut JDK正则表达式切点。必须在Spring的配置文件中配置。匹配需要被切入的方法。定义时使用正则表达式。

• NameMatchMethodPointcut 在Spring的配置文件中配置，只关注方法，也可以使用正则表达式。

  • 概念：Advice（通知）

通知Advice，就是拦截到方法后要增加的功能，可以在原方法执行前、后、出异常等等时机增加处理代码。

通知都是Advice接口的实现类。

通知的类型有：

  • 前置通知
  • 后置通知
  • 环绕通知
  • 异常通知
  • 最终通知
  • 概念：Advisor/aspect（切面）

在Spring当中，通过将“通知”和“切入点”进行关联完整的定义一个切面。

注解方式实现AOP编程

  1. 先引入aop相关jar文件 （aspectj aop优秀组件）
    • spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】
    • aopalliance.jar 【spring2.5源码/lib/aopalliance】
    • aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
    • aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

注意： 用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。 需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。

  1. bean.xml中引入aop名称空间
  2. 开启aop注解
  3. 使用注解

  • @Aspect 指定一个类为切面类

  • @Pointcut("execution(* cn.itcast.e_aop_anno..(..))") 指定切入点表达式

  • @Before("pointCut_()") 前置通知: 目标方法之前执行

  • @After("pointCut_()") 后置通知：目标方法之后执行（始终执行）

  • @AfterReturning("pointCut_()") 返回后通知： 执行方法结束前执行(异常不执行)

  • @AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行

  • @Around("pointCut_()") 环绕通知： 环绕目标方法执行

1. IUserDao.java
// 接口
public interface IUserDao {
	void save();
}

2. UserDao.java
/**
 * 目标对象
 * @author Jie.Yuan
 *
 */
@Component   // 加入容器
public class UserDao implements IUserDao{

	@Override
	public void save() {
		System.out.println("-----核心业务：保存！！！------"); 
	}
}

3. Aop.java  切面类

@Component
@Aspect  // 指定当前类为切面类
public class Aop {

	// 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象
	
	@Pointcut("execution(* cn.csx.e_aop_anno.*.*(..))")
	public void pointCut_(){
	}
	
	// 前置通知 : 在执行目标方法之前执行
	@Before("pointCut_()")
	public void begin(){
		System.out.println("开始事务/异常");
	}
	
	// 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
	@After("pointCut_()")
	public void after(){
		System.out.println("提交事务/关闭");
	}
	
	// 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
	@AfterReturning("pointCut_()")
	public void afterReturning() {
		System.out.println("afterReturning()");
	}
	
	// 异常通知： 当目标方法执行异常时候执行此关注点代码
	@AfterThrowing("pointCut_()")
	public void afterThrowing(){
		System.out.println("afterThrowing()");
	}
	
	// 环绕通知：环绕目标方式执行
	@Around("pointCut_()")
	public void around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("环绕前....");
		pjp.proceed();  // 执行目标方法
		System.out.println("环绕后....");
	}
	
}
4. bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- 开启注解扫描 -->
	<context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>
	
	<!-- 开启aop注解方式 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>   


App.java

public class App {
	
	ApplicationContext ac = 
		new ClassPathXmlApplicationContext("cn/csx/e_aop_anno/bean.xml");

	// 目标对象有实现接口，spring会自动选择“JDK代理”
	@Test
	public void testApp() {
		IUserDao userDao = (IUserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
	}
	
	// 目标对象没有实现接口， spring会用“cglib代理”
	@Test
	public void testCglib() {
		OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
		System.out.println(orderDao.getClass());
		orderDao.save();
	}
}

XML方式实现AOP编程

Xml实现aop编程：

  1. 引入jar文件 【aop 相关jar， 4个】
  2. 引入aop名称空间
  3. aop 配置
    • 配置切面类 （重复执行代码形成的类）
    • aop配置
      • 拦截哪些方法 / 拦截到方法后应用通知代码
<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- dao 实例 -->
	<bean id="userDao" class="cn.csx.f_aop_xml.UserDao"></bean>
	<bean id="orderDao" class="cn.csx.f_aop_xml.OrderDao"></bean>
	
	<!-- 切面类 -->
	<bean id="aop" class="cn.csx.f_aop_xml.Aop"></bean>
	
	<!-- Aop配置 -->
	<aop:config>
		<!-- 定义一个切入点表达式： 拦截哪些方法 -->
		<aop:pointcut expression="execution(* cn.csx.f_aop_xml.*.*(..))" id="pt"/>
		<!-- 切面 -->
		<aop:aspect ref="aop">
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pt"/>
			<!-- 前置通知： 在目标方法调用前执行 -->
			<aop:before method="begin" pointcut-ref="pt"/>
			<!-- 后置通知： -->
			<aop:after method="after" pointcut-ref="pt"/>
			<!-- 返回后通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
			<!-- 异常通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
			
		</aop:aspect>
	</aop:config>
</beans>

切入点表达式

切入点表达式,

可以对指定的“方法”进行拦截； 从而给指定的方法所在的类生层代理对象。

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- dao 实例 -->
	<bean id="userDao" class="cn.csx.g_pointcut.UserDao"></bean>
	<bean id="orderDao" class="cn.csx.g_pointcut.OrderDao"></bean>
	
	<!-- 切面类 -->
	<bean id="aop" class="cn.csx.g_pointcut.Aop"></bean>
	
	<!-- Aop配置 -->
	<aop:config>
		
		<!-- 定义一个切入点表达式： 拦截哪些方法 -->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.*.*(..))" id="pt"/>-->
		
		<!-- 【拦截所有public方法】 -->
		<!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
		
		<!-- 【拦截所有save开头的方法 】 -->
		<!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->
		
		<!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
		<!--<aop:pointcut expression="execution(public * cn.csx.g_pointcut.OrderDao.save(..))" id="pt"/>-->
		
		<!-- 【拦截指定类的所有方法】 -->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.UserDao.*(..))" id="pt"/>-->
		
		<!-- 【拦截指定包，以及其自包下所有类的所有方法】 -->
		<!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
		
		<!-- 【多个表达式】 -->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.UserDao.save()) || execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.UserDao.save()) or execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!-- 下面2个且关系的，没有意义 -->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn.csx.g_pointcut.UserDao.save()) and execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>-->
		
		<!-- 【取非值】 -->
		<!--<aop:pointcut expression="!execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>-->
		<aop:pointcut expression=" not execution(* cn.csx.g_pointcut.OrderDao.save())" id="pt"/>
		
		<!-- 切面 -->
		<aop:aspect ref="aop">
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pt"/>
		</aop:aspect>
	</aop:config>
</beans>
chen-sx
关注
专栏目录
小马哥讲 Spring AOP 编程思想 - API 线索图.pdf
04-13
在讨论Spring AOP（面向切面编程）时，首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块，它允许开发者将横切关注点（cross-cutting concerns）从业务逻辑中解耦出来，通过在方法调用前后进行...
spring aop编程示例
08-07
实战示例
Spring AOP编程
10-10
想要跑起来，项目中，你要： （1）设置本地Maven的路径指向 （2）安装ssm-parent到本地仓库 （3）删除ssm-web-test（指向的Location可能和你的电脑磁盘路径不一致） （4）重新导入import 已经存在的 Maven ...
Spring AOP编程实例
05-03
**Spring AOP编程实例** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的核心特性之一，它提供了一种在不修改原有代码的情况下，通过插入额外的行为（如日志、事务管理等）来增强功能的...
SpringIOC容器
chen-sx
06-24 1782
SpringIOC容器 概述 SpringIOC容器，是spring核心内容。 作用： 创建对象 & 处理对象的依赖关系 创建对象 IOC容器创建对象： 创建对象, 有几种方式： 调用无参数构造器带参数构造器工厂创建对象 工厂类，静态方法创建对象工厂类，非静态方法创建对象 beans xmlns="http://www.spr
Spring与JDBC,事务管理
chen-sx
06-25 761
Spring与JDBC,事务管理 Spring+JDBC组合开发 配置数据源（c3p0） 使用c3p0连接池，需要先把c3p0的jar包添加到工程中。我们在配置时把数据库连接信息放到外面单独的jdbc.properties文件中。 context:property-placeholder location="classpath:jdbc.properties" />
Spring入门
chen-sx
06-24 513
Spring入门 Spring介绍 Spring是一个非常活跃的开源框架, 它是一个基于IOC和 AOP来构架多层JavaEE系统的框架,它的主要目地是简化 企业开发 Spring以一种非侵入式的方式来管理你的代码, Spring提 倡”最少侵入”，这也就意味着你可以适当的时候安装 或卸载Spring Spring模块 为什么使用Spring 降
Spring基础
chen-sx
06-24 436
Spring基础 Spring概述 Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。 且可以和其他框架一起使用；Spring与Struts, Spring与hibernate (起到整合（粘合）作用的一个框架) Spring提供了一站式解决方案： Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系Spring Web
Matlab Toolbox for Interval Type-2 Fuzzy Logic Systems.rar
最新发布
09-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于java的大学生第二课堂设计与实现.docx
09-20
基于java的大学生第二课堂设计与实现.docx
vue+SpringBoot442大学校园快递代取管理系统的设计与实现java毕业设计源码含论文.rar
09-20
jdk版本:jdk1.8+ 前端：vue.js+ElementUI 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：springboot 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+springboot+vue+MYSQL+MAVEN 前端采用的Vue框架，后端采用java语言，sprinboot框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统
win和android安卓平台的播放器 .zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
application.properties
09-20
application.properties
【语音分离】通过分析信号的FFT，根据音频使用合适的滤波器进行语音信号分离Matlab代码.rar
09-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
使用 javaEE，MySQL，jsp，jQuery，bootstrap，华为云搭建的小网站——奇异果物品管理平台(毕设&课设&
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
MATLAB 中的工具箱用于对架空和地下输电线路进行建模（单位长度参数、传播特性、频率扫描、瞬态模拟）.rar
09-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
linux常用命令大全.docx
09-20
linux常用命令大全
罗彩琳23002374.cpp
09-20
罗彩琳23002374.cpp
Spring AOP编程：接口代理与动态代理实战
作者田超凡在2019年6月6日创作了这篇文档，旨在介绍如何在SpringAOP环境中利用Java的动态代理技术来增强业务逻辑的可维护性和灵活性。 首先，文档定义了一个名为`HelloAop`的接口，它包含一个名为`show`的方法，这...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值