视频功能审核通过了，可以看视频啦！记得点关注啊~
 
注意：因为网络原因，视频前一两分钟可能会比较模糊，过一会儿就好了
 
记得点关注啊，视频里的wx二维码失效了，wx搜索：“聊5毛钱的java” 或 扫码关注公众号，欢迎一起学习交流
 
 
快扫码关注啦！关注可领取博主的Java学习视频+资料，保证都是干货
 

 
 
SpringAOP系列，帮你了解SpringAOP的来龙去脉
 
上篇介绍了一下静态代理：Java中的代理模式——静态代理以及分析静态代理的缺点
 
静态代理是程序运行前，代理类的.class文件已经存在了。
 
动态代理是，在程序运行时运用反射机制动态创建而成，无需手动编写代码
 
也分析了一下静态代理的缺点：
 
1、由于静态代理中的代理类是针对某一个类去做代理的，那么假设一个系统中有100个Service，则需要创建100个代理类
 
2、如果一个Service中有很多方法需要事务（增强动作），发现代理对象的方法中还是有很多重复的代码
 
3、由第一点和第二点可以得出：静态代理的重用性不强
 
那怎么解决呢？
 
用动态代理就可以很好的解决上述问题，本篇介绍一下：Java中的动态代理
 
动态代理实现的目的和静态代理一样，都是对目标方法进行增强，而且让增强的动作和目标动作分开，达到解耦的目的
 
动态代理分为JDK的动态代理和cglib动态代理
 
它俩有略微的差别：JDK动态代理产生的代理类和目标类实现了相同的接口；cglib动态代理产生的代理类是目标对象的子类。
 
下面分别介绍JDK的动态代理（是JDK的代码实现的）和cglib动态代理（是cglib的jar包实现的）
 
1、JDK的动态代理
 
package com.cj.study.proxyjdk;

public interface PersonService {
	
	public String savePerson();
	
	public void updatePerson();
	
	public void deletePerson();
	
}
 
package com.cj.study.proxyjdk;

public class PersonServiceImpl implements PersonService{

	@Override
	public String savePerson() {
		System.out.println("添加");
		return "保存成功！";
	}

	@Override
	public void updatePerson() {
		System.out.println("修改");
	}

	@Override
	public void deletePerson() {
		System.out.println("删除");
	}

}
 
package com.cj.study.proxyjdk;

public class MyTransaction {
	public void beginTransaction(){
		System.out.println("开启事务 ");
	}
	public void commit(){
		System.out.println("提交事务");
	}
}
 
注意：在动态代理在生成代理对象的时候需要一个拦截器 InvocationHandler 因此咱们需要写一个拦截器
 
package com.cj.study.proxyjdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class PersonServiceInterceptor implements InvocationHandler{
	//目标类
	private Object target;
	//增强类
	private MyTransaction myTransaction;
	//构造函数注入目标类和增强类
	public PersonServiceInterceptor(Object target,MyTransaction myTransaction){
		this.target = target;
		this.myTransaction = myTransaction;
	}

	//代理类的每一个方法被调用的时候都会调用下边的这个invoke方法
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		this.myTransaction.beginTransaction();
		Object returnValue = method.invoke(this.target, args);
		this.myTransaction.commit();
		return returnValue;
	}
	
}
 
注意：
 
1、当客户端执行代理对象.方法时，进入到了拦截器的invoke方法体
 
2、拦截器中invoke方法体的内容就是代理对象方法体的内容
 
3、拦截器中invoke方法的method参数是在调用的时候赋值的
 
package com.cj.study.proxyjdk;

import java.lang.reflect.Proxy;
import org.junit.Test;

public class ProxyTest {
	@Test
	public void test(){
		Object target = new PersonServiceImpl();
		MyTransaction myTransaction = new MyTransaction();
		PersonServiceInterceptor interceptor = new PersonServiceInterceptor(target, myTransaction);
		PersonService personService = (PersonService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),interceptor);
		String returnValue = (String)personService.savePerson();
		System.out.println(returnValue);
	}
}
 
可以打断点看下
 
 
发现生成的对象是 $Proxy4 说明返回的已经是我们的代理对象了
 
最后的运行结果
 
 
2、cglib动态代理
 
首先需要导入cglib的jar包：cglib-nodep-2.1_3.jar
 
package com.cj.study.proxycglib;

public interface PersonService {
	
	public String savePerson();
	
	public void updatePerson();
	
	public void deletePerson();
	
}
 
package com.cj.study.proxycglib;

public class PersonServiceImpl implements PersonService{

	@Override
	public String savePerson() {
		System.out.println("添加");
		return "保存成功！";
	}

	@Override
	public void updatePerson() {
		System.out.println("修改");
	}

	@Override
	public void deletePerson() {
		System.out.println("删除");
	}

}
 
package com.cj.study.proxycglib;

public class MyTransaction {
	public void beginTransaction(){
		System.out.println("开启事务 ");
	}
	public void commit(){
		System.out.println("提交事务");
	}
}
 
package com.cj.study.proxycglib;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class PersonServiceInterceptor implements MethodInterceptor{
	//目标类
	private Object target;
	//增强类
	private MyTransaction myTransaction;
	//构造函数注入目标类和增强类
	public PersonServiceInterceptor(Object target,MyTransaction myTransaction){
		this.target = target;
		this.myTransaction = myTransaction;
	}
	
	public Object createProxy(){
		Enhancer enhancer = new Enhancer();
		enhancer.setCallback(this);
		enhancer.setSuperclass(this.target.getClass());
		return enhancer.create();
	}

	@Override
	public Object intercept(Object arg0, Method arg1, Object[] arg2,
			MethodProxy arg3) throws Throwable {
		myTransaction.beginTransaction();
		Object returnValue = arg1.invoke(this.target, arg2);
		myTransaction.commit();
		return returnValue;
	}
	
}
 
package com.cj.study.proxycglib;

import org.junit.Test;

public class ProxyTest {
	@Test
	public void test(){
		Object target = new PersonServiceImpl();
		MyTransaction myTransaction = new MyTransaction();
		PersonServiceInterceptor interceptor = new PersonServiceInterceptor(target, myTransaction);
		PersonService personService =(PersonService) interceptor.createProxy();
		String returnValue = (String)personService.savePerson();
		System.out.println(returnValue);
	}
}
 
最后的运行结果
 
 
最后需要知道的点：
 
1、JDK动态代理，要求目标类实现接口，但是有时候目标类直接一个单独的对象，并没有实现任何的接口，这时就得使用CGLib动态代理
 2、JDK动态代理是JDK里自带的，CGLib动态代理需要引入第三方的jar包
 
3、CGLib动态代理，它是在内存中构建一个子类对象，从而实现对目标对象功能的扩展
 4、CGLib动态代理，是基于继承来实现代理，所以无法对final类、private方法和static方法进行代理
 
 
以上就是动态代理的两种实现。
 
我们用上边的做法去实现目标方法的增强，实现代码的解耦，是没有问题的，但是还是需要自己去生成代理对象，自己手写拦截器，在拦截器里自己手动的去把要增强的内容和目标方法结合起来，这用起来还是有点繁琐，有更好的解决方案吗？
 
答案是：有的！那就是Spring的AOP，这才是咱们最终想引出来的重点！
 
有了Spring的AOP后，就不用自己去写了，只需要在配置文件里进行配置，配置好后Spring按照你的配置去帮你生成代理对象，按照你的配置把增强的内容和目标方法结合起来。就相当于自己写代码也能实现和aop类似的功能，但是有了Spring aop以后有些事情Spring帮你做了，而且人家Spring做成了可配置化，用起来非常简单而且很灵活
 
咱们上边用的JDK动态代理和cglib动态代理，这两种在Spring的AOP里都有用到，Spring是根据不同的情况去决定是使用JDK的动态代理生成代理对象，还是使用cglib去生成代理对象，具体的内容下一篇会讲到。
 
下一篇我们继续：讲一下Spring中的AOP以及切入点表达式和各种通知
 
铁子们，如果觉得文章对你有所帮助，可以点关注，点赞
 
也可以关注下公众号：扫码或 wx搜索：“聊5毛钱的java”，欢迎一起学习交流，关注公众号可领取博主的Java学习视频+资料，保证都是干货
 
 
3Q~
 
纯手敲原创不易，如果觉得对你有帮助，可以打赏支持一下，哈哈，感谢~
 
           
 

App抓包 抖音Api抓包 HTTPS抓包 Charles抓包 抖音去水印
 
（2021-03-11更新）
 
 


 
目录
 
App抓包 抖音Api抓包 HTTPS抓包 Charles抓包 抖音去水印
前言
一、Charles
1.下载地址
2.证书安装
  
二、手机设置
1.手机代理设置
2.手机安装证书
1.charles导出证书
2.手机下载证书
  
  
三.效果展示
最后

 
 
前言
 
charles作为抓包工具比Fillder功能更加强大，支持跨平台使用，推荐使用。本文以抖音app为例，实现用PC抓包手机app请求，仅供学习，不得作为商业用途。
 
 
一、Charles
 
1.下载地址
 
官网：https://www.charlesproxy.com/
 补丁：https://www.zzzmode.com/mytools/charles/
 
2.证书安装
 

 
 
 
 最后下一步安装导入证书，此时PC端能正常抓包了。
 
之后为手机抓包做准备
 
 
 

 
 到此为止，Charles设置已经全部完成
 若浏览器不能正常访问其他网站，请去掉此规则，或暂时关闭windows proxy
 
二、手机设置
 
1.手机代理设置
 
首先获取电脑在局域网的ip地址
 
 
 
设置好ip地址和端口号，但是这样并不能抓https链接的包，要安装ssl证书
 
2.手机安装证书
 
1.charles导出证书
 

 
 
2.手机下载证书
 
手机自带浏览器(safari)输入chls.pro/ssl，下载证书
 
 
手机打开 设置→通用→描述文件 安装证书
 
 
手机打开 设置→关于本机→证书信任设置 信任证书
 
 
三.效果展示
 

 截取到抖音后台数据
 其他接口有兴趣的大家可以自己深入研究，可以获取用户信息，点赞列表，关注列表等等，有机会我再单独写个帖子
 
最后
 
如果觉得这篇文章帮到了您，希望您支持一下，生活困苦，且行且珍惜，大家随意！
 
 
抖音去水印python源码下载：https://download.csdn.net/download/hjn0618/15514789

 
 
  
概述
实例
 
 
 
 
 
概述
 
引介增强是一种比较特殊的增强类型，它不是在目标方法周围织入增强，而是为目标创建新的方法和属性，所以它的连接点是类级别的而非方法级别的。
 
通过引介增强我们可以为目标类添加一个接口的实现即原来目标类未实现某个接口,那么通过引介增强可以为目标类创建实现某接口的代理。 
 
Spring定义了引介增强接口IntroductionInterceptor，该接口没有定义任何方法 
 
 
Spring为该接口提供了DelegatingIntroductionInterceptor实现类，一般情况下，通过扩展该实现类定义自己的引介增强类。
 
 
实例
 
代码已托管到Github—> https://github.com/yangshangwei/SpringMaster
 
我们一直使用的性能检测的例子。 开启监控会影响业务系统的性能，我们可以设置是否启用性能监视为可控的，那我们改如何使用引介增强实现这一个诱人的功能呢？ 
 
我们创建一个示例来演示下，步骤如下： 
 创建接口类：Monitorable.java 
 创建业务类：PerformanceMonitor.java 
 创建增强类：ControllablePerformanceMonitor.java 
 创建配置文件：conf-advice.xml 
 创建增强测试类：DelegatingTest.java
 
 
接口类：Monitorable.java
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

public interface Monitorable {
    void setMonitorActive(boolean active);
}
 
该接扣仅包含一个setMonitorActive方法，我们希望通过该接口方法控制业务类性能监视功能的激活和关闭状态
 
接下来创建业务类
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

public class PerformanceMonitor {
    private static ThreadLocal<MethodPerformace> performaceRecord = new ThreadLocal<MethodPerformace>();

    public static void begin(String method) {
        System.out.println("begin monitor...");
        MethodPerformace mp = performaceRecord.get();
        if (mp == null) {
            mp = new MethodPerformace(method);
            performaceRecord.set(mp);
        } else {
            mp.reset(method);
        }
    }

    public static void end() {
        System.out.println("end monitor...");
        MethodPerformace mp = performaceRecord.get();
        mp.printPerformace();
    }
}
 
接下来创建增强类ControllablePerformanceMonitor
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;

public class ControllablePerformaceMonitor extends
        DelegatingIntroductionInterceptor implements Monitorable {

    private static final long serialVersionUID = 1L;
    // 定义ThreadLocal类型的变量，用于保存性能监视开关状态。 为了解决单实例线程安全的问题，通过ThreadLocal
    // 让每个线程单独使用一个状态
    private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>();

    @Override
    public void setMonitorActive(boolean active) {
        MonitorStatusMap.set(active);
    }

    /**
     * 拦截方法
     */
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        Object obj = null;
        // 对于支持新跟那个监视可控代理，通过判断其状态决定是否开启性能监控功能
        // Java5.0的自动拆包功能，get方法返回的Boolean被自动拆包为boolean类型的值
        if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) {
            PerformanceMonitor.begin(mi.getClass().getName() + "."
                    + mi.getMethod().getName());
            obj = super.invoke(mi);
            PerformanceMonitor.end();
        } else {
            obj = super.invoke(mi);
        }
        return obj;
    }

}

 
接下来创建所要增强的方法类
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

public class ForumService {
    public void removeTopic(int topicId) {
        System.out.println("模拟删除Topic记录:" + topicId);
        try {
            Thread.currentThread().sleep((long) (Math.random() * 1000 * 20));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

    public void removeForum(int forumId) {
        System.out.println("模拟删除Forum记录:" + forumId);
        try {
            Thread.currentThread().sleep((long) (Math.random() * 1000 * 20));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

public class MethodPerformace {
    private long begin;
    private long end;
    private String serviceMethod;

    public MethodPerformace(String serviceMethod) {
        reset(serviceMethod);
    }

    public void printPerformace() {
        end = System.currentTimeMillis();
        long elapse = end - begin;
        System.out.println(serviceMethod + "花费" + elapse + "毫秒。");
    }

    public void reset(String serviceMethod) {
        this.serviceMethod = serviceMethod;
        this.begin = System.currentTimeMillis();
    }
}
 
创建配置文件来将所设置的代码组合起来
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="pmonitor"
        class="com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor.ControllablePerformaceMonitor" />
    <bean id="forumServiceTarget" class="com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor.ForumService" />

    <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean"
        p:interfaces="com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor.Monitorable"
        p:target-ref="forumServiceTarget" 
        p:interceptorNames="pmonitor"
        p:proxyTargetClass="true" />

</beans>
 
引介增强的配置和一般配置有较大的区别，
 
首先需要指定引介增强所实现的接口 ，如 p:interfaces ，这里的引介增强实现了Monitorable接口。
其次，由于只能通过为目标类创建子类的方式生成引介增强的代理，所以必须将 p:proxyTargetClass=”true”
 
如果没有对ControllablePerformaceMonitor进行线程安全的处理，就必须将singleton属性设置为false, 让ProxyFactoryBean产生prototype的作用域类型的代理。 这里就带来了一个严重的性能问题，因为cglib动态创建代理的性能很低，而每次getBean方法从容器中获取作用域为prototype的Bean时都将返回一个新的代理实例，所以这种影响是巨大的，这也是为什么通过ThreadLocal对ControllablePerformaceMonitor的开关进行线程安全化处理的原因。 通过线程安全处理后，就可以使用默认的singleton Bean作用域，这样创建代理的动作仅发生一次。
 
创建对应的测试类
 
package com.xgj.aop.spring.advice.DelegatingIntroductionInterceptor;

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

public class DelegatingTest {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/aop/spring/advice/DelegatingIntroductionInterceptor/conf-advice.xml");
        ForumService forumService = (ForumService) ctx.getBean("forumService");
        forumService.removeForum(10);
        forumService.removeTopic(1022);

        Monitorable moniterable = (Monitorable) forumService;
        moniterable.setMonitorActive(true);
        forumService.removeForum(10);
        forumService.removeTopic(1022);
    }
}
 
运行结果
 
 

 
 
  
导读
概述
实现类介绍
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator
AOP总结
 
 
 
 
 
导读
 
Spring-AOP 自动创建代理
 
Spring-AOP 自动创建代理之BeanNameAutoProxyCreator
 
Spring-AOP 自动创建代理之DefaultAdvisorAutoProxyCreator
 
Spring-AOP 自动创建代理之AnnotationAwareAspectJAutoProxyCreator
 
 
概述
 
我们通过前面几篇博文的案例，我们会发现都是通过ProxyFactoryBean创建织入切面的代理，每个需要被代理的Bean都需要使用一个ProxyFactoryBean进行配置。 
 
幸好Spring提供了自动代理机制，让容器自动生成代理，把开发人员从繁琐的配置中解脱出来。在内部，Spring使用BeanPostProcessor自动完成这项工作
 
 
实现类介绍
 
基于BeanPostProcessor的自动代理创建器的实现类，将根据一些规则自动在容器实例化Bean时为匹配的Bean生成代理内容。
 
这些代理创建器可以分为3类
 
基于Bean配置名规则的自动代理创建器 
 允许为一组特定配置名的Bean自动创建代理实例的代理创建器，实现类为BeanNameAutoProxyCreator
基于Advisor匹配机制的自动代理创建器 
 它会对容器中所有的Advisor进行扫描，自动将这些切面应用到匹配的Bean中（为目标Bean创建代理实例），实现类为DefaultAdvisorAutoProxyCreator
基于Bean中的AspectJ注解标签的自动代理创建器 
 为包含AspectJ注解的Bean自动创建代理实例，实现类为AnnotationAwareAspectJAutoProxyCreator.
 
自动创建代理器实现类的继承图
 
 
可以清楚的看到所有的自动代理器类都实现了BeanPostPorcessor，在容器实例化Bean时，BeanPostProcessor将对它进行加工处理，所以自动代理创建器有机会对满足匹配规则的bean自动创建代理对象
 
 
BeanNameAutoProxyCreator
 
请参考另外一篇博文 Spring-AOP 自动创建代理之BeanNameAutoProxyCreator
 
 
DefaultAdvisorAutoProxyCreator
 
请参考另外一篇博文 Spring-AOP 自动创建代理之DefaultAdvisorAutoProxyCreator
 
 
AnnotationAwareAspectJAutoProxyCreator
 
请参考另外一篇博文 Spring-AOP 自动创建代理之AnnotationAwareAspectJAutoProxyCreator
 
 
AOP总结
 
AOP是OOP的延伸，它为程序开发提供了一个崭新的思考角度，将可以重复性的横切逻辑抽取到统一的模块中，通过OOP的纵向抽象和AOP的横向抽取，程序才可以真正解决重复性代码问题。 
 
Spring采用JDK动态代理和CGLib动态代理技术在运行期织入增强，所以不需要装备特殊的编译器或类装载器就可以使用AOP功能。 
 
要使用JDK动态代理，目标类必须实现接口，而CGLib不对目标类作任何限制，它通过动态生成目标类子类的方式提供代理。
 
在JDK动态代理中通过接口来实现方法拦截，所以必须确保要拦截的目标在接口中有定义，否则将无法拦截
 
在CGLib动态代理中通过动态生成代理子类来实现方法拦截，所以必须确保要拦截的目标方法可以被子类访问，也就是目标方法必须定义为非final,且非私有实例方法。
 
JDK在创建代理对象时的性能高于CGLib，而生成的代理对象的运行性能却比CGLib低。 如果是singleton的代理，推荐使用CGlib动态代理。
 
Spring只能在方法级别上织入增强，Spring提供了4种类型的方法增强，分别是前置增强、后置增强、环绕增强、异常抛出增强，此外还有一种特殊的引介增强。 引介增强是类级别的，它为目标类织入新的接口实现。 从广义上将，增强其实是一种最简单的切面，它既包括横切代码又包括切点信息，只不过它的切点只是简单的方法相对位置信息。 所以增强一般需要和切点联合才可以表示一个更具实用性的切面。
 
在Spring中，普通的切点通过目标类名和方法名描述连接点的信息。 流程切点是比较特殊的切点，它通过方法调用堆栈的运行环境来决定连接点。 有时候需要通过切点的交叉或者合并描述一个最终的切点，可以使用ComposablePointcut的复合切点
 
切面是增强和切点的联合体，可以很方便的通过Spring提供的ProxyFactoryBean将切面自入不同的目标类中。 当然为每个目标类手工配置一个切面是比较繁琐的，Spring利用BeanPostProcessor可干涉Bean生命周期的机制，提供一些可以自动创建代理、自入切面的自动代理创建器，其中DefaultAdvisorAutoProxyCreator是功能强大的自动代理穿件器，它可以将容器中所有的Advisor自动织入目标Bean中。