/**

 * 相当于一个beans

 */

@Configuration

@ComponentScan(basePackages = "xiaodao.spring")

public class SpringConfiguration {

    public SpringConfiguration() {

        System.out.println("spring 容器启动");

    }

    /**

     * bean id 默认是bean的方法名

     * @return

     */

 /*   @Bean

    public UserService userService(){

        return new UserServiceImpl();

    }*/

}

public class SpringConfigurationTest {

    @Test

    public void test1(){

        //创建纯注解方式的spring 容器

        ApplicationContext applicationContext  = new AnnotationConfigApplicationContext(SpringConfiguration.class);

        UserService userService = (UserService) applicationContext.getBean("userService");

       userService.save();

    }

}

@Configuration

@ComponentScan(basePackages = "com.kkb.spring")

@Import({ JdbcConfig.class})

public class SpringConfiguration {

}

@Configuration

@PropertySource("classpath:jdbc.properties")

public class JdbcConfig{

    }

public interface UserService {

    public void save();

}

@Service("userService")

public class UserServiceImpl implements UserService {

    public void save() {

        System.out.println("userserviceimpl  save方法");

    }

}

public class MyProxyUtils {

    /**

     * 使用JDK动态代理类

     * @param userServiceInterface

     * @return

     */

    public static UserService getProxy(final UserService userServiceInterface){

        /**

         * proxy是jdk中的代理类

         * 1.目标对象的类加载器

         * 2.目标对接的接口

         * 3.代理对象的执行处理器

         */

     UserService userService = (UserService) Proxy.newProxyInstance(userServiceInterface.getClass().getClassLoader(), userServiceInterface.getClass().getInterfaces(), new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("记录日志-开始");

                //下面的代码是,反射中的api用法

                //方法

                //2.参数

                //这行代码实际还是调用目标对象的方法

                Object invoke = method.invoke(userServiceInterface, args);

                System.out.println("记录日志结束");

                return invoke;

            }

        });

        return userService;

    }

    /**

     * 使用cglib的方式动态代理技术实现

     * 它是基于继承的方式实现的

     * @param userService

     * @return

     */

    public static UserService getProxyByCglib(UserService userService){

        //创建增强器

        Enhancer enhancer =new Enhancer();

        //这里设置增强类的类对象-实现类的类对象

        enhancer.setSuperclass(UserServiceImpl.class);

        //设置回调函数

        enhancer.setCallback(new MethodInterceptor() {

            /**

             *

             * @param o

             * @param method

             * @param args 方法参数

             * @param methodProxy 代理之后的对象的方法

             * @return

             * @throws Throwable

             */

            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

                long start = System.currentTimeMillis();

                System.out.println("cglib 记录开始时间:  "+start);

                //代理对象是目标的对象的子类

                //这行代码实际还是调用目标对象的方法

                //o 是代理对象

                Object object = methodProxy.invokeSuper(o, args);

                long end = System.currentTimeMillis();

                System.out.println("cglib 记录结束时间:  "+end);

                return object;

            }

        });

        // 获取增强之后的代理对象.

        return (UserService) enhancer.create();

    }

}

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:application.xml")

public class TestAOP {

    @Autowired

    private UserService userService;

    @Test

    public void test(){

        userService.save();

    }

}

userservice 还是刚刚那个userservice
@Service("userService")

public class UserServiceImpl implements UserService {

    public void save() {

        System.out.println("userserviceimpl  save方法");

        System.out.println(1/0);

    }

}

@Aspect

@Component("myaspect")

//相当于<aop:aspectj-proxy>

@EnableAspectJAutoProxy

public class MyAspect {

    //定义该方法是一个前置通知

    @Before(value = "execution(* xiaodao.spring.service.*.*())")

    public void before(){

        System.out.println("注解前置通知");

    }

    @After(value = "execution(* xiaodao.spring.service.*.*())")

    public void after(){

        System.out.println("注解后置通知");

    }

    @AfterReturning(value = "func()")

    public void end(){

        System.out.println("最终通知");

    }

    @Pointcut(value = "execution(* xiaodao.spring.service.*.*())")

    public void func(){

    }

}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

 @Override

 public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

   if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {

     Class<?> targetClass = config.getTargetClass();

     if (targetClass == null) {

       throw new AopConfigException("TargetSource cannot determine target class: " +

           "Either an interface or a target is required for proxy creation.");

     }

       // 判断目标类是否是接口或者目标类是否Proxy类型，若是则使用JDK动态代理

     if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {

       return new JdkDynamicAopProxy(config);

     }

       // 配置了使用CGLIB进行动态代理或者目标类没有接口，那么使用CGLIB的方式创建代理对象

     return new ObjenesisCglibAopProxy(config);

   }

   else {

       // 上面的三个方法没有一个为true，那使用JDK的提供的代理方式生成代理对象

     return new JdkDynamicAopProxy(config);

   }

 }

   //其他方法略……

}

public class ProxyConfig implements Serializable {

    /** use serialVersionUID from Spring 1.2 for interoperability */

    private static final long serialVersionUID = -8409359707199703185L;

    private boolean proxyTargetClass = false;

    private boolean optimize = false;

    boolean opaque = false;

    boolean exposeProxy = false;

    private boolean frozen = false;

.........

}