Spring AOP
AOP相关所涉及到的概念
- 连接点 程序执行过程中全部可植入逻辑的点，spring仅支持方法级别的连接点，所以连接点就指方法
- 切点 切点用来选择连接点
- 通知 具体执行逻辑
- 切面 抽象概念，是连接点、切点、通知的包装
- 织入 织入是个动作，就是在切点的引导下，将通知逻辑加到连接点上
以XML配置形式为例，在配置<aop:config>标签时，已经包含了以上除"织入"外的所有信息！
Spring初始化时，会将以上信息加载成Advisor对象（集合）
Advisor对象包含三个部分
-
Advice
- 对应<aop:before、after配置，即为每个连接点创建一个对象
- 内部主要属性是一个Method类型的对象，对应的就是<aop:before method=“xxx”>的"method"属性指向的方法反射类对象
-
Pointcut
- 提供匹配逻辑，就是根据execution表达式判断当前调用方法是否匹配
-
order
- int类型，用来排序，因为切面可以有多个，多个切面通过这个来决定执行顺序，加载通知list集合时，会sort一下
至此AOP相关信息大部分加载完了
接下来就是基于动态代理的创建过程
加载bean时会通过AOP相关后置处理器（DefaultAdvisorAutoProxyCreator）以execution表达式判断当前对象是否符合，匹配上就创建一个代理对象，当调用代理对象时，首先根据当前调用方法（代理类对象调用时都会传递method对象）
1、在上面初始化的Advisor集合里选择
2、根据PointCut对象判断是否匹配
3、将匹配的Advisor构建成拦截器对象，并构造成拦截器链
这里要注意，Advisor对象已经是前置后置[通知类型]的Advisor对象AspectJMethodBeforeAdvice、AfterReturningAdvice等等，在构造拦截器对象时会构造对应[通知类型]的拦截器MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor等，为什么要这样，一是为了适配，适应处理流程，二是为了保证通知调用顺序问题，其实就是每个拦截器对象里有拦截器链的引用，前置通知是先调用通知再调用拦截器链，而后置通知是先调用拦截器链再调用后置通知，这样操作会使即使后置拦截器先调用也会先把其他拦截器执行完了才会执行自己
4、然后就是拦截器链的调用
BeanPostProcessor 是Spring AOP实现的重要基础，bean在初始化前后会调用BeanPostProcessor的before/after方法执行自定义增强逻辑，这个接口是AOP与IOC产生联系的入口
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
创建bean时会找到所有BeanPostProcessor实现类，然后循环执行前后增强方法（有order属性，可以定义优先级），AOP注册启动类如下文中DefaultAdvisorAutoProxyCreator，它就是一个BeanPostProcessor
####代理过程
AbstractAutowireCapableBeanFactory（bean的实例化入口） -> doCreateBean -> initializeBean
Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
// 省略...
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 1. 执行每一个 BeanPostProcessor 的 postProcessBeforeInitialization 方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用 bean 配置中的 init-method="xxx"
invokeInitMethods(beanName, wrappedBean, mbd);
}
// 省略...
if (mbd == null || !mbd.isSynthetic()) {
// 我们关注的重点是这里！！！
// 2. 执行每一个 BeanPostProcessor 的 postProcessAfterInitialization 方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName){
Object result = existingBean;
// 获取所有BeanPostProcessor实现类，分别执行其[前/后]增强方法
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
回到上面AOP配置的启动类DefaultAdvisorAutoProxyCreator，它是BeanPostProcessor子类，实现了后置增强
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
// 判断当前创建bean是否需要包装增强
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 省略...
// 匹配当前 bean 的所有的 advisor、advice、interceptor
// 对于上面xml的配置那就是pattern规则下的bean，对于注解如事务，那就是加了@Transaction的bean
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, N );
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理...创建代理...创建代理...
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
当前创建bean存在通知链，则为其创建代理类，创建代理类的逻辑在**ProxyFactory.createAopProxy()**中
这里插播一个手动调用spring aop的main代码块，这其实就已经包含了整个aop所涉及到的元素
--main 手动调用spring aop--
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setOptimize(false);//是否进行代理优化，默认false
proxyFactory.setProxyTargetClass(true);//是否为代理类，默认false
proxyFactory.addAdvice(new MyAdvice());//增强类
proxyFactory.setTarget(new ApiImpl());//被代理类
Api obj = (Api) proxyFactory.getProxy();
obj.say();
System.out.println(proxyFactory.getProxy().getClass().getName());
--spring ProxyFactory--
public Object getProxy() {return createAopProxy().getProxy();}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//是否对代理策略进行优化[boolean] 是否是代理类[boolean] 是否实现接口
//<aop:config proxy-target-class="true"> 这俩都是可配的
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();//被代理对象
if (targetClass == null) {
throw new AopConfigException("");
}//是接口？获取已经是JAVA Proxy代理生成的类
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}else {
return new JdkDynamicAopProxy(config);
}
}
JdkDynamicAopProxy对象实际上就是InvocationHandler，生成的proxy字节码里都是h.invoke，也就是说调用代理对象的具体方法say()之前，其实内部调用的是JdkDynamicAopProxy内部的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
// 省略...
// 根据method对象获取该方法上的拦截链，在bean初始化时，已经通过注册启动类的
// BeanPostProcessor前后增强方法为每个bean初始化好了Advisor链Map
// (实际上是获取Advisor通知，然后被包装成拦截器)
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// 如果没有拦截器链，则直接调用，method.invoke(target, args)
// method对象其实就是代理对象里的反射Method对象,Proxy字节码里已经按 Method
// m3 = Class.forName("com.yao.HelloWorld").getMethod("sayHello", new Class[0]);
// 这种提前构造好了，本质上就是一个反射调用
if (chain.isEmpty()) {
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// 构造执行器对象，并调用proceed方法递归/回调调用，执行完整个链
// 具体执行逻辑是由[通知-advice]对象来定
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}
// 省略...
return retVal;
}
}
@Override
public Object proceed() throws Throwable {
// 如果剩最后一个，invokeJoinpoint用来执行自己的方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// 动态advisor...
} else {
// 执行增强逻辑，前面已经将advisor逻辑包装在了interceptor对象的invoke方法里
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
获取拦截器链
获取/构造拦截器对象（根据通知对象的before、after类型构造出相应类型的Interceptor对象，注意是循环初始化的那3种"adapters"来判断）
将"Advice"通知对象构造成相应通知类型（前置、后置）的拦截器对象
拦截器的invoke方法内部对前后置通知提供支持（持有拦截器链引用，后置就是先执行链再执行后置保证了即使先调后置也会先走前置）
Spring事务（基于注解）
必须配置开启事务标签，只有加了开启标签才能生效（开启标签本质上是通知容器，让他注册相应的bean）
<tx:annotation-driven />
TX命名空间解析器
org.springframework.transaction.config.TxNamespaceHandler#init#AnnotationDrivenBeanDefinitionParser#AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext)
共注册三个bean
-
InfrastructureAdvisorAutoProxyCreator BeanFactory增强（BeanPostProcessor类型）
通过postProcessAfterInitialization方法，为当前bean匹配事务相关Advisor通知（即匹配@Transaction注解），并为其创建代理对象
-
TransactionInterceptor Advice（增强）类型，
真正执行具体事务逻辑，包括开启事务、提交、回滚、传播性处理等等
-
BeanFactoryTransactionAttributeSourceAdvisor Advisor包装类型
封装Pointcut（切点）、Advice（增强），包含切面织入的所有属性（Poincut对象封装在了这个里面，通过通知对象来获取切面对象，实现不同切面逻辑）
至此，事务相关Adivsor已经初始化完毕
根据bean上是否存在@Transaction注解（包括方法、类上）创建了proxy代理对象的bean（一般就是service对象）后，执行具体方法时执行的就是JdkDynamicAopProxy逻辑，重点关注的是事务的具体处理逻辑，入口是invoke方法
// TransactionInterceptor#invoke
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// Adapt to TransactionAspectSupport's invokeWithinTransaction...
return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback({
// 回调至JdkDynamicAopProxy.proceed()
@Override
public Object proceedWithInvocation() throws Throwable {
return invocation.proceed();
}
});
}
protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation) {
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
final String joinpointIdentification = methodIdentification(method, targetClass);
if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
// 根据注解传播属性@Transactional(propagation = Propagation.XXX)判断是否需要开启事务
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr,
joinpointIdentification);
Object retVal = null;
try {
// 执行上面的那个回调方法，最终会执行自己的方法
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
retVal = invocation.proceedWithInvocation();
} catch (Throwable ex) {
// 出现异常，回滚或回滚到回滚点
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
} finally {
cleanupTransactionInfo(txInfo);
}
commitTransactionAfterReturning(txInfo);
return retVal;
}
// 省略...
}
protected TransactionInfo createTransactionIfNecessary(
PlatformTransactionManager tm, TransactionAttribute txAttr,
String joinpointIdentification) {
if (txAttr != null && txAttr.getName() == null) {
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
if (txAttr != null) {
if (tm != null) {
// 获取事务
status = tm.getTransaction(txAttr);
} else {
if (logger.isDebugEnabled()) {
logger.debug("...");
}
}
}
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
@Override
public final TransactionStatus getTransaction(TransactionDefinition definition) {
// 从TransactionSynchronizationManager的ThreadLocal<Map<Object, Object>> resources
// 中获取当前线程所持有的数据库连接包装对象
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
// 判断是否已存在事务，这里就是对事务传播特性的逻辑
// transaction.getConnectionHolder() != null &&
// transaction.getConnectionHolder().isTransactionActive()
if (isExistingTransaction(transaction)) {
return handleExistingTransaction(definition, transaction, debugEnabled);
}
// Check definition settings for new transaction.
if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout");
}
// No existing transaction found -> check propagation behavior to find out how to proceed.
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException("No existing transaction
found for transaction marked with propagation 'mandatory'");
} else if (
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
SuspendedResourcesHolder suspendedResources = suspend(null);
try {
boolean newSynchronization =
(getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true,
newSynchronization, debugEnabled, suspendedResources);
// 开启事务
doBegin(transaction, definition);
prepareSynchronization(status, definition);
return status;
} catch (RuntimeException ex) {
resume(null, suspendedResources);
throw ex;
} catch (Error err) {
resume(null, suspendedResources);
throw err;
}
}
else {
// 省略...
}
}
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
// 当前线程下没有数据库连接对象
// 通过dataSource获取数据库连接connection，并将连接设置进包装对象里
if (txObject.getConnectionHolder() == null ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
Connection newCon = this.dataSource.getConnection();
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// 设置非自动提交 setAutoCommit(false)
if (con.getAutoCommit()) {
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);
}
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// 绑定数据库连接对象到当前线程上
if (txObject.isNewConnectionHolder()) {// Bind the session holder to the thread.
TransactionSynchronizationManager.
bindResource(getDataSource(), txObject.getConnectionHolder());
}
}
// 省略...
}
// suspend 挂起事务
@Override
protected Object doSuspend(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
txObject.setConnectionHolder(null);
// 将数据库连接对象与当前线程解绑
ConnectionHolder conHolder = (ConnectionHolder)
TransactionSynchronizationManager.unbindResource(this.dataSource);
return conHolder;
}
事务传播特性
- PROPAGATION_REQUIRED – 如果当前没有事务，就新建事务，存在事务，则加入当前事务
- PROPAGATION_SUPPORTS – 如果当前没有事务，就以非事务方式执行，存在则加入当前事务
- PROPAGATION_NOT_SUPPORTED – 如果当前存在事务，就把当前事务挂起，自己以非事务运行
- PROPAGATION_MANDATORY – 如果当前没有事务，就抛出异常
- PROPAGATION_REQUIRES_NEW – 如果当前无事务则新建事务，如果存在事务则挂起当前事务，开启新事务
- PROPAGATION_NEVER – 如果当前存在事务，则抛出异常
- PROPAGATION_NESTED – 如果当前存在事务，则在嵌套事务内执行，否则新建事务
PROPAGATION_NESTED为嵌套事务，基于JDBC3.0的SavePoint特性，它是事务中的子事务，跟随主事务提交，执行嵌套事务时，首先创建回滚点savePoint，当自身业务异常时，会回滚到回滚点，而非回滚整个事务
举例：假设有一张日志表Logs，用于日志记录，插入日志表有任何异常我们不希望回滚整个事务
Connection con = DBConnection.getConnection();
con.setAutoCommit(false);
insertOutbound(con, args…);
insertOutboundItem(con, args…);
SavePoint savePoint = con.setSavePoint(“logs”);
insertLog();
con.commit();
catch -> 捕获到异常
savePoint != null -> 等于null则证明是插入log之前的异常，那用正常的回滚
con.rollback(savePoint);
con.commit(); // 再次提交
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled) {
// 事务传播属性
TransactionDefinition behavior = definition.getPropagationBehavior();
// [对应6] 如果当前存在事务，则抛出异常
if (behavior == TransactionDefinition.PROPAGATION_NEVER) {
throw new IllegalTransactionStateException(
"Existing transaction found for transaction marked with propagation 'never'");
}
// [对应3] 如果当前存在事务，就把当前事务挂起，自己以非事务运行
if (behavior == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
// 挂起当前事务
Object suspendedResources = suspend(transaction);
boolean newSynchronization =
(getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
return prepareTransactionStatus(
definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
// [对应5] 如果当前存在事务，把当前事务挂起，开启新事务运行
if (behavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
// 挂起当前事务
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
boolean newSynchronization =
(getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
DefaultTransactionStatus status =
newTransactionStatus(
definition, transaction, true,
newSynchronization, debugEnabled, suspendedResources);
// 开启新事务
doBegin(transaction, definition);
prepareSynchronization(status, definition);
return status;
} catch (RuntimeException beginEx) {
resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
} catch (Error beginErr) {
resumeAfterBeginException(transaction, suspendedResources, beginErr);
throw beginErr;
}
}
// [对应7] 如果当前存在事务，则在嵌套事务内执行。否则新建事务
if (behavior == TransactionDefinition.PROPAGATION_NESTED) {
// 判断是否支持savePoint特性，JDBC 3.0
if (useSavepointForNestedTransaction()) {
DefaultTransactionStatus status =
prepareTransactionStatus(definition, transaction, false,
false, debugEnabled, null);
// 创建savePoint savepoint = con.setSavepoint("name");
status.createAndHoldSavepoint();
return status;
} else {
// 若不支持则新建事务
boolean newSynchronization =
(getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, null);
doBegin(transaction, definition);
prepareSynchronization(status, definition);
return status;
}
}
// [对应1][对应2] 若存在事务，则加入当前事务（就是啥也不干，不做数据库连接切换）
// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
if (debugEnabled) {
logger.debug("Participating in existing transaction");
}
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
return prepareTransactionStatus(definition, transaction,
false, newSynchronization, debugEnabled, null);
}
###JDK动态代理的使用
public interface Helloworld {
void sayHello();
}
public class HelloworldImpl implements HelloWorld {
public void sayHello() {
System.out.print("hello world");
}
}
// 动态代理类，实现java InvocationHandler接口，重写invoke方法
public class MyInvocationHandler implements InvocationHandler{
private Object target;
public MyInvocationHandler(Object target) {
this.target=target;
}
@override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method :"+ method.getName()+" is invoked!");
return method.invoke(target,args);
}
}
public static void main(String[]args) {
// newProxyInstance(classLoader, 被代理类接口列表, 动态代理类对象)
HelloWorld helloWorld = (HelloWorld)Proxy.
newProxyInstance(JDKProxyTest.class.getClassLoader(),
new Class<?>[]{HelloWorld.class},
new MyInvocationHandler(new HelloworldImpl()));
helloWorld.sayHello();
}
代理过程
根据反射获取被代理类的信息，构造代理类所需的信息如包名、类名等，最终：
调用ProxyGenerator.generateProxyClass()方法生成类的数据流
调用native方法defineClass0，将类数据流生成类字节码文件，并加入JVM
注意：接口列表存在同样的方法签名，生成的代理类只会生成一个对应方法（Api1 extends Api2 都有say()方法）
生成的动态代理class结构
主要逻辑就是 h.invoke，h 就是Proxy.newProxyInstance时传入的MyInvocationHandler对象，即调用代理类的**“每个”**方法时，其实都是调用 InvocationHandler的invoke方法，这样就形成了每个方法调用时都有前后增强
package com.sun.proxy;
import com.yao.HelloWorld;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements HelloWorld {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void sayHello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.yao.HelloWorld").getMethod("sayHello", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
tatic {
try {
m1 = Class.forName(“java.lang.Object”).getMethod(“equals”, new Class[]{Class.forName(“java.lang.Object”)});
m3 = Class.forName(“com.yao.HelloWorld”).getMethod(“sayHello”, new Class[0]);
m2 = Class.forName(“java.lang.Object”).getMethod(“toString”, new Class[0]);
m0 = Class.forName(“java.lang.Object”).getMethod(“hashCode”, new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
