Superclass has no null constructors but no arguments were given

admin

在做AOP 日志记录时  启动项目报如下错误
% o& d% Y& h' Y2 i! E9 U$ G
java.lang.IllegalArgumentException: Superclass has no null constructors but no arguments were given  

  G: Z' z  a7 Z大概意思是说   父类没有空的构造函数但没有给出参数  出自百度翻译。

% ^1 b$ r- c/ D/ Z; {" W" S说明一下：
1 p. j- e9 X! E& z5 a4 A- H4 V在类没有实现任何接口，并且没有默认构造函数的情况下，通过构造函数注入时，目前的spring是无法实现AOP切面拦截的。

" X, l" R" h* W# V. \' ^. |6 d也就是说 生成一个空的构造方法即可。
原因分析
4 B1 q; w1 z1 c' j3 F
4 V* e. D' K6 L3 b. L【前提】本文提到的没有实现接口，使用构造函数注入的类是Service层的类，并且注入的是Dao对象。
9 t+ o4 _: J1 W7 I( \4 x我把Service类中加了默认构造函数，测试了一下，果然成功了，但是我就纳闷了，为什么加个默认构造函数就行了呢？如果是真的使用了这个默认构造函数生成类对象，那么起码Dao是根本就没有被注入到Service中的，而我在实际的测试中，读写数据库一切正常，显然意味着Dao对象是已经注入到Service对象里了。
, i" K0 `9 L; y7 g' X
$ [" X' P; m8 m按照Spring in Action书中所述：
如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。在创建这个类的时候，Spring将通知织入，并且将对目标对象的调用委托给这个子类。

这段叙述不足以让大家理解到底Spring是如何借助于CGLIB来实现AOP拦截的，在Debug Spring代码过程中，我惊奇的发现，实际上，Spring确实借助于CGLIB生成了个子类，但这个子类只是一个壳，只是原来目标类对象的一个代表，当我们调用目标类的方法时，从表面上看，是被CGLIB生成的子类接受到了，调的是子类的方法，而实际上当子类对象的方法被调用时，又回调了目标类对象的方法。当然在回调时，可以在目标对象的方法被调用前后加点切面处理。

这样一看，CGLIB生成的目标对象的这个子类，还真是个名副其实的代理（只是代表着目标对象的样子，实际上一有处理就转交目标对象处理了），我们只要想办法搞出这个子类的对象就可以了，由于他是直接回调的目标对象，所以，即使我们所必须的Dao没有被注入到子类对象也是没有关系的。
" B" m0 N7 J( _& N8 v
2 y9 D  m2 }7 z然而，最大的不幸是在下面。
% G9 a5 b1 r9 s' W在AOP切进来之前，实际上目标类的对象已经被注满了东西，也被初始化完毕了，然后，才将AOP切进来。
在AOP切进来时，对于实现了接口的类，直接用了JDK的动态代理，把目标对象扔给JDK的Proxy，拿到代理对象就完事大吉了。
然而对于没有实现接口的类，就麻烦了，当然肯定的借助于CGLIB来实现代理。
不幸就在这里，当Spring在制造完了目标对象后，并没有将在生产目标对象进所用的注入构造函数的参数对象传给AOP处理这部分，也就是说当到了AOP这块处理时，目标对象是传过来了，但当时生产它时候所用的构造函数的参数对象并没有一起传过了。
) t0 W" c6 O# X8 [* {% \  ^/ j作为使用构造函数注入的目的之一：保证注入属性的不可变性。自然，我们也不会给目标类再安上构造函数注入属性的set/get方法。

, G4 J5 J2 M9 D5 \于是乎，当到了DefaultAopProxyFactory类下面的处理时，Spring根本无法将目标对象的构造函数参数对象传给Cglib2AopProxy对象。Cglib2AopProxy类的setConstructorArguments方法也只能是眼巴巴的看着异常的发生。因为到了CGLIB在制造代理对象时，ReflectUtils类的getConstructor方法根本就找不到默认的构造函数，于时异常最终发生了。
  s: y  h( w6 l4 W. s6 A( f& w6 q
7 Z) K7 l' k* P$ E- F: u$ d/ rDefaultAopProxyFactory类中的内部CglibProxyFactory
6 m3 e' p; }# k: m2 t

1.         private static class CglibProxyFactory {
   
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   
4.                         return new Cglib2AopProxy(advisedSupport);
   
5.                 }
   
6.         }

复制代码

ReflectUtils类的getConstructor方法

1.     public static Constructor getConstructor(Class type, Class[] parameterTypes) {
   5 Z: E. V/ X0 }. v4 v- d$ `
2.         try {
   
3.             Constructor constructor = type.getDeclaredConstructor(parameterTypes);
   ) C( A. q% X3 `! G6 c
4.             constructor.setAccessible(true);
   ! N/ z3 c# _8 J: P
5.             return constructor;
   
6.         } catch (NoSuchMethodException e) {
   / Y- K6 P$ @8 d1 {( _
7.             throw new CodeGenerationException(e);
   . I9 O- l, }8 }; h, u5 t
8.         }
   & N3 y  K5 t( [& ?* E) }$ e) _
9.     }

复制代码

/ S2 V, m1 \5 r8 u5 Z4 DCglib2AopProxy类的setConstructorArguments方法
3 x% T! O9 j! Q, ^6 N注：该方法，Spring的AOP处理中并没有使用。

1.         public void setConstructorArguments(Object[] constructorArgs, Class[] constructorArgTypes) {
   
2.                 if (constructorArgs == null || constructorArgTypes == null) {
   4 r2 O. |; l$ n& N
3.                         throw new IllegalArgumentException("Both 'constructorArgs' and 'constructorArgTypes' need to be specified");
   0 ]0 D* R$ C( n5 m5 r2 u9 q" m
4.                 }
   
5.                 if (constructorArgs.length != constructorArgTypes.length) {
   4 F" ]* b) L8 `' x7 ?+ D
6.                         throw new IllegalArgumentException("Number of 'constructorArgs' (" + constructorArgs.length +
   
7.                                         ") must match number of 'constructorArgTypes' (" + constructorArgTypes.length + ")");
   * C9 t: A# D& h3 [0 ^+ k
8.                 }
   
9.                 this.constructorArgs = constructorArgs;
   % O5 G: o+ [7 p# e. y- }4 D9 n& s
10.                 this.constructorArgTypes = constructorArgTypes;
    
11.         }

复制代码

Cglib2AopProxy类的getProxy方法片段
8 ]/ X  c" r- C% r  y- `8 |" u

1.                         // Generate the proxy class and create a proxy instance.
   0 m5 c8 @, r# Q' R" J# r3 ]
2.                         Object proxy;
   
3.                         if (this.constructorArgs != null) {
   
4.                                 proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
   
5.                         }
   - s. p  V7 X3 R9 M* v- L: E) o
6.                         else {
   0 u! T+ o9 d( b/ v
7.                                 proxy = enhancer.create();
   
8.                         }

复制代码

, x  e( u2 u3 q* ?& M以上的分析就差不多结束了，恰恰是因为Spring通过CGLIB生成代理类对象时，并没有将目标对象的构造函数的参数及其类型进行设定，导致了CGLIB在生成代理类对象时，会使用默认的构造函数生成，结果目标对象类没有默认构造函数，CGLIB生成子类时，也没有加入默认构造函数，所以，异常的发生成为必然。

解决方案
5 K1 \2 G; ?3 J' ]4 f% N7 C有人说，我们都用接口就好了，为什么一定要不用接口呢。
1 a, f7 `; O+ \: ~正如CGLIB代理引入的初衷：遗留系统或无法实现接口的第三方类库同样可以得到通知。
! B- S$ D2 J( }! M* F/ E
以下的方案只是抛砖引玉，简单实现，如果您的条件更恶劣（情况更复杂），还需要进一步改造。
% v/ @7 J$ F' ?1 s3 m" r7 G+ y; e
+ g/ U( ?: k* z: j( O( F3 P$ }在上文我也提到，只要能生成出目标对象的子类对象，DAO注不注到子类对象里根据无关轻重，反而注入并不见得是好事。Spring借助目标对象的壳来实现代理功能，我们的目标也就是实现这个壳，让这个壳能顺利的生成出来。
明白了这个道理就好办多了。我们可以把org.springframework.aop.framework.DefaultAopProxyFactory类的源代码拷贝到我们的环境中，对其内部类CglibProxyFactory进行改造。
( V; s; G9 g6 T& m. H下面的代码中，我先获得目标对象的构造函数的类型，然后利于CGLIB生产一个这样的对象，通过c2aop.setConstructorArguments(new Object[] { enhancer.create() }, clazz);传给Cglib2AopProxy对象。这样，当CGLIB生成目标对象子类的对象时，就会正确的生产出来了。

* q& {. f# ^5 {0 }  C' Q3 x9 k2 \9 Y! {注：我现在测试用的Service类的构造函数只有一个Dao参数。

0 V* W  w9 E# c- x1 o
改造前：
+ k' ]  U& n3 Y% ]1 G5 [

1.         private static class CglibProxyFactory {
   * w% n( h5 c8 G' l$ h* z) d; e
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   3 _! y1 E4 W% R& r  q2 d
4.                         return new Cglib2AopProxy(advisedSupport);
   
5.                 }
   0 |$ V  c9 g& H  s
6.         }

复制代码

改造后：
- s: o0 `$ X7 t) }6 E; r$ M. C

1.         private static class CglibProxyFactory {
   ) {6 \6 D; B0 u  z1 P& C
2. 
   
3.                 public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
   
4.                         Cglib2AopProxy c2aop = new Cglib2AopProxy(advisedSupport);
   7 \! p& Q7 s. w6 b$ z
5.                        
   5 K+ G% [  q4 j7 w' i9 V
6.                         Object obj;
   
7.                         try {
   3 H0 r8 S: A0 O9 E0 P* |
8.                                 obj = advisedSupport.getTargetSource().getTarget();
   
9.                                 if (null == obj) {
   
10.                                         throw new Exception("错误：找不到目标对象！");
    4 W$ o0 B# S9 Z) p5 t0 d8 d  @
11.                                 }
    - M8 J# v' b5 [8 T, m# @
12.                         } catch (Exception e) {
    
13.                                 e.printStackTrace();
    
14.                                 throw new RuntimeException(e);
    
15.                         }
    " v' A% C$ o6 }: x" y! v
16. 
    
17.                         Constructor[] cstructs = obj.getClass().getDeclaredConstructors();
    
18.                         if (cstructs.length == 1) {
    
19.                                 Constructor cstruct = cstructs[0];
    - A, W' ~! \! B
20.                                 Class[] clazz = cstruct.getParameterTypes();
    : ?* ]1 k. n1 w0 Q. `4 W; ]3 w( o5 T
21. 
    0 A& D: b1 l; [) v4 {4 ?* _9 t
22.                                 if (clazz.length == 1) {
    
23.                                         Enhancer enhancer = new Enhancer();
    1 W5 U2 e& U7 n! L3 H
24.                                         enhancer.setSuperclass(clazz[0]);
    ' r* u" ]1 w. ]
25.                                         enhancer.setCallback(new MethodInterceptorImpl());
    ( t. Q& r0 j% r8 g5 G4 V4 T) d! ]
26. 
    . ~( L/ p$ S* ^- N
27.                                         c2aop.setConstructorArguments(new Object[] { enhancer.create() }, clazz);
    9 X; c* r( o0 ~) B
28.                                 }
    
29.                         }
    : y- @4 H$ h7 U- @9 V- x
30. 
    ) s. r1 T; ?, V! e4 A
31.                         return c2aop;
    . M; e6 b0 E6 P% f. _; l- O2 l' X  e
32.                 }
    3 c& ]. y/ v+ R  U6 b5 d
33.         }
    1 i8 a6 w  b4 _6 H
34. 
    
35.         private static class MethodInterceptorImpl implements MethodInterceptor {
    6 c7 n4 g* n8 }# }
36.                 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
    & M7 p( N1 a" r* v7 a; `
37.                                 throws Throwable {
    2 C* U$ s# }* q
38.                         proxy.invokeSuper(obj, args);
    
39.                         return null;
    
40.                 }
    
41.         }

复制代码

  N" |6 I) [; B4 n  s+ J! }再说一点，实际上，如果能从CGLIB入手，在生产目标对象类的子类时，加上一个默认构造函数就帅了。
' N  l  Q& |% Q但是对CGLIB进行改造，难度不是一半点，所以，还是直接改Spring的类来的直接些。
! o+ v# V0 Q+ J3 v7 t. a  {! i

0 C$ B4 D. y2 v/ D! j原文转自：http://www.iteye.com/problems/7876