Superclass has no null constructors but no arguments were given

admin

在做AOP 日志记录时  启动项目报如下错误

( ~- d( Q: j# R- n1 S java.lang.IllegalArgumentException: Superclass has no null constructors but no arguments were given  

( Q; Y& s# Q/ x大概意思是说   父类没有空的构造函数但没有给出参数  出自百度翻译。
3 y- C) ^0 g. P5 |0 Q
说明一下：
0 Y9 \7 `0 G) t4 i- N/ M6 B  U% ]6 `在类没有实现任何接口，并且没有默认构造函数的情况下，通过构造函数注入时，目前的spring是无法实现AOP切面拦截的。
, R  j* m' Q( {* p
8 {2 o, Q! S, m7 h也就是说 生成一个空的构造方法即可。
原因分析
7 x/ f: C( s' D2 M/ x4 p
% x$ [- D4 o+ q) J$ o8 [( h" Q【前提】本文提到的没有实现接口，使用构造函数注入的类是Service层的类，并且注入的是Dao对象。
( G& J- x9 `) ?8 z+ B我把Service类中加了默认构造函数，测试了一下，果然成功了，但是我就纳闷了，为什么加个默认构造函数就行了呢？如果是真的使用了这个默认构造函数生成类对象，那么起码Dao是根本就没有被注入到Service中的，而我在实际的测试中，读写数据库一切正常，显然意味着Dao对象是已经注入到Service对象里了。

$ b0 p; @3 C7 U* @. n' R# x按照Spring in Action书中所述：
  M2 J% C2 l* B, h如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。在创建这个类的时候，Spring将通知织入，并且将对目标对象的调用委托给这个子类。
6 \' G8 A/ F; m& ^; R- @3 ^
, h, f- L$ [5 k" a这段叙述不足以让大家理解到底Spring是如何借助于CGLIB来实现AOP拦截的，在Debug Spring代码过程中，我惊奇的发现，实际上，Spring确实借助于CGLIB生成了个子类，但这个子类只是一个壳，只是原来目标类对象的一个代表，当我们调用目标类的方法时，从表面上看，是被CGLIB生成的子类接受到了，调的是子类的方法，而实际上当子类对象的方法被调用时，又回调了目标类对象的方法。当然在回调时，可以在目标对象的方法被调用前后加点切面处理。
8 `" ?/ ~( ?( ~. j5 D
这样一看，CGLIB生成的目标对象的这个子类，还真是个名副其实的代理（只是代表着目标对象的样子，实际上一有处理就转交目标对象处理了），我们只要想办法搞出这个子类的对象就可以了，由于他是直接回调的目标对象，所以，即使我们所必须的Dao没有被注入到子类对象也是没有关系的。

. `3 t% j# ^) A! L9 n然而，最大的不幸是在下面。
+ _$ B- E+ n8 {2 t在AOP切进来之前，实际上目标类的对象已经被注满了东西，也被初始化完毕了，然后，才将AOP切进来。
在AOP切进来时，对于实现了接口的类，直接用了JDK的动态代理，把目标对象扔给JDK的Proxy，拿到代理对象就完事大吉了。
3 Q: t9 e- H) r: Y( A; V* Y8 Q然而对于没有实现接口的类，就麻烦了，当然肯定的借助于CGLIB来实现代理。
不幸就在这里，当Spring在制造完了目标对象后，并没有将在生产目标对象进所用的注入构造函数的参数对象传给AOP处理这部分，也就是说当到了AOP这块处理时，目标对象是传过来了，但当时生产它时候所用的构造函数的参数对象并没有一起传过了。
作为使用构造函数注入的目的之一：保证注入属性的不可变性。自然，我们也不会给目标类再安上构造函数注入属性的set/get方法。

于是乎，当到了DefaultAopProxyFactory类下面的处理时，Spring根本无法将目标对象的构造函数参数对象传给Cglib2AopProxy对象。Cglib2AopProxy类的setConstructorArguments方法也只能是眼巴巴的看着异常的发生。因为到了CGLIB在制造代理对象时，ReflectUtils类的getConstructor方法根本就找不到默认的构造函数，于时异常最终发生了。
" @, E3 \. o) U" `" B
+ l) O& o- ?5 ]0 H7 c1 A) _DefaultAopProxyFactory类中的内部CglibProxyFactory

1.         private static class CglibProxyFactory {
   
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   ' A, J9 v- ?8 Q7 C: T" p2 m4 {) `
4.                         return new Cglib2AopProxy(advisedSupport);
   
5.                 }
   ( e# `, k1 m$ v0 Y, z
6.         }

复制代码

ReflectUtils类的getConstructor方法
, W0 |+ B7 Y& l

1.     public static Constructor getConstructor(Class type, Class[] parameterTypes) {
   % M- ?6 ~' o. d$ t4 A% ?! q+ R
2.         try {
   0 R) r. Q/ }2 y/ r! O3 l% X
3.             Constructor constructor = type.getDeclaredConstructor(parameterTypes);
   0 Z8 j! x8 J1 G" X; l' L3 W
4.             constructor.setAccessible(true);
   1 }- Y0 K2 G3 \3 ?& k6 Q" t6 }
5.             return constructor;
   % T  @& _" R" z4 s, o
6.         } catch (NoSuchMethodException e) {
   # Y! @. X) s* M* ^0 {
7.             throw new CodeGenerationException(e);
   
8.         }
   . l! C* \# V1 i, L- F4 L
9.     }

复制代码

/ T- @# N$ G! J+ F$ v! QCglib2AopProxy类的setConstructorArguments方法
9 E& H) N, L; I4 n& t' e注：该方法，Spring的AOP处理中并没有使用。

1.         public void setConstructorArguments(Object[] constructorArgs, Class[] constructorArgTypes) {
   9 J1 v" l8 q' l) g, L
2.                 if (constructorArgs == null || constructorArgTypes == null) {
   ' n2 p& k' H2 x6 w, g+ I0 z
3.                         throw new IllegalArgumentException("Both 'constructorArgs' and 'constructorArgTypes' need to be specified");
   # }3 x" k0 O) [6 p9 a
4.                 }
   # S' H/ M0 e5 g5 l* ~% y
5.                 if (constructorArgs.length != constructorArgTypes.length) {
   
6.                         throw new IllegalArgumentException("Number of 'constructorArgs' (" + constructorArgs.length +
   
7.                                         ") must match number of 'constructorArgTypes' (" + constructorArgTypes.length + ")");
   % Z# d- i( F8 {
8.                 }
   4 W* S' L4 n) l7 V, R& ]1 A1 u
9.                 this.constructorArgs = constructorArgs;
   : ~6 c! M" o, ~3 P% |. y
10.                 this.constructorArgTypes = constructorArgTypes;
    / n5 w4 P/ ]" V  s' A
11.         }

复制代码

Cglib2AopProxy类的getProxy方法片段

1.                         // Generate the proxy class and create a proxy instance.
   
2.                         Object proxy;
   ! O' `/ F+ h) }1 k3 X# [+ _
3.                         if (this.constructorArgs != null) {
   + j2 d; f  P0 X3 e& j
4.                                 proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
   $ V- W8 k  a; Z  ]6 R
5.                         }
   . D( B1 T4 d& m  R) D4 m9 s$ q
6.                         else {
   
7.                                 proxy = enhancer.create();
   
8.                         }

复制代码

以上的分析就差不多结束了，恰恰是因为Spring通过CGLIB生成代理类对象时，并没有将目标对象的构造函数的参数及其类型进行设定，导致了CGLIB在生成代理类对象时，会使用默认的构造函数生成，结果目标对象类没有默认构造函数，CGLIB生成子类时，也没有加入默认构造函数，所以，异常的发生成为必然。
- K  W/ T/ n0 n0 j; }5 V  A
解决方案
有人说，我们都用接口就好了，为什么一定要不用接口呢。
正如CGLIB代理引入的初衷：遗留系统或无法实现接口的第三方类库同样可以得到通知。
& Q6 O) \' s5 b
以下的方案只是抛砖引玉，简单实现，如果您的条件更恶劣（情况更复杂），还需要进一步改造。

在上文我也提到，只要能生成出目标对象的子类对象，DAO注不注到子类对象里根据无关轻重，反而注入并不见得是好事。Spring借助目标对象的壳来实现代理功能，我们的目标也就是实现这个壳，让这个壳能顺利的生成出来。
7 }# o. |, ~1 }明白了这个道理就好办多了。我们可以把org.springframework.aop.framework.DefaultAopProxyFactory类的源代码拷贝到我们的环境中，对其内部类CglibProxyFactory进行改造。
7 T. B- w/ ?8 w4 g0 u4 m下面的代码中，我先获得目标对象的构造函数的类型，然后利于CGLIB生产一个这样的对象，通过c2aop.setConstructorArguments(new Object[] { enhancer.create() }, clazz);传给Cglib2AopProxy对象。这样，当CGLIB生成目标对象子类的对象时，就会正确的生产出来了。
$ K+ _3 x9 u$ ^0 v. C- R7 t
注：我现在测试用的Service类的构造函数只有一个Dao参数。

8 K. I5 c3 i% `5 f+ ?6 Y, ^$ h
改造前：
0 I2 _9 V. T4 u

1.         private static class CglibProxyFactory {
   
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   % a. |% |" M9 V  _' D8 g3 e( x0 v
4.                         return new Cglib2AopProxy(advisedSupport);
   
5.                 }
   
6.         }

复制代码

改造后：
( A4 d- ?7 s% u( Q8 U' h- F8 O

1.         private static class CglibProxyFactory {
   
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   
4.                         Cglib2AopProxy c2aop = new Cglib2AopProxy(advisedSupport);
   
5.                        
   * G" t9 R& x! ^! K
6.                         Object obj;
   + V- d6 Z- }2 l4 o5 b! O2 }, s2 C
7.                         try {
   
8.                                 obj = advisedSupport.getTargetSource().getTarget();
   / _. \: U. F0 g
9.                                 if (null == obj) {
   5 U4 t3 Q& X, x, K# L# {3 F
10.                                         throw new Exception("错误：找不到目标对象！");
    
11.                                 }
    2 A+ ?& ^0 T( Z) h4 ~& w
12.                         } catch (Exception e) {
    
13.                                 e.printStackTrace();
    ' V) `7 I" Y: ~6 j
14.                                 throw new RuntimeException(e);
    ( U9 p' |# C3 ~! N3 C  h
15.                         }
    
16. 
    / m3 W; ~& ]$ K
17.                         Constructor[] cstructs = obj.getClass().getDeclaredConstructors();
    6 M. X" t; E: u( o, F
18.                         if (cstructs.length == 1) {
    
19.                                 Constructor cstruct = cstructs[0];
    . ^& A6 ?3 ?+ I  X8 N8 N$ b; K  b
20.                                 Class[] clazz = cstruct.getParameterTypes();
    6 U- X1 O4 i$ T" `
21. 
    . ?; Z- q3 Y2 y3 g* o5 o* n
22.                                 if (clazz.length == 1) {
    
23.                                         Enhancer enhancer = new Enhancer();
    ' s0 W1 H/ i! g6 K" \/ }5 `
24.                                         enhancer.setSuperclass(clazz[0]);
    
25.                                         enhancer.setCallback(new MethodInterceptorImpl());
    
26. 
    
27.                                         c2aop.setConstructorArguments(new Object[] { enhancer.create() }, clazz);
    
28.                                 }
    
29.                         }
    
30. 
    - ?  u) ^+ M2 u( ~
31.                         return c2aop;
    
32.                 }
    
33.         }
    
34. 
    
35.         private static class MethodInterceptorImpl implements MethodInterceptor {
    + V) r3 @2 d: T2 w8 q: m
36.                 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
    - {  U& k/ m3 f" \! o: G$ S# {
37.                                 throws Throwable {
    0 u! m- w  T1 D( K1 k
38.                         proxy.invokeSuper(obj, args);
    
39.                         return null;
    
40.                 }
    
41.         }

复制代码

; d9 ]* d1 X& g+ a9 ^0 K3 v再说一点，实际上，如果能从CGLIB入手，在生产目标对象类的子类时，加上一个默认构造函数就帅了。
但是对CGLIB进行改造，难度不是一半点，所以，还是直接改Spring的类来的直接些。
+ v9 v  j1 a$ [: F8 _

  X- M! A& r# k1 y原文转自：http://www.iteye.com/problems/7876
  s) Z7 I9 W  R$ b1 G