<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xmlns:context="http://www.springframework.org/schema/context"

        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <!--bean的名字是u， id是名字为u的对象 -->

    <bean  id="u" class="com.test.spring.dao.UserDAOImpl" />

    <!-- property中的userDAO参考的bean（u） -->

    <bean id="userService" class="com.test.spring.service.UserServiceImpl">

        <property  name="userDAO" ref="u" />

    </bean>

</beans>

package com.test.spring.model;

public class User {

    private String username;

    private String password;

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

package com.test.spring.dao;

import com.test.spring.model.User;

public interface UserDAO {

    public void save(User u);

    public void delete();

}

package com.test.spring.dao;

import com.test.spring.model.User;

/**

 * 与数据库打交道，管理数据库，将数据屏蔽

 * @author Administrator

 *

 */

public class UserDAOImpl implements UserDAO

{

    @Override

    public void save(User u) {

        System.out.println("saved!!!");

    }

    @Override

    public void delete() {

        System.out.println("delete!!!");

    }

}

package com.test.spring.service;

import com.test.spring.dao.UserDAO;

import com.test.spring.model.User;

/**

 * 管理层，与Bean层打交道，和与数据库管理层DAO层打交道

 * @author Administrator

 *

 */

public interface UserService {

    public void add(User u);

}

package com.test.spring.service;

import com.test.spring.dao.UserDAO;

import com.test.spring.dao.UserDAOImpl;

import com.test.spring.model.User;

/**

 * 负责是的业务逻辑，而DAO层只负责数据库层

 * @author Administrator

 *

 */

public class UserServiceImpl implements UserService

{

    //可以调用UserDAO将User存入到数据库中，所以要new一个UserDAOImpl的引用

    private UserDAO userDAO = new UserDAOImpl();

    public UserDAO getUserDAO() {

        return userDAO;

    }

    public void setUserDAO(UserDAO userDAO) {

        this.userDAO = userDAO;

    }

    public void add(User u) {

        this.userDAO.save(u);

    }

}

package test.test;

import java.lang.reflect.Proxy;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.test.spring.aop.LogInterceptor;

import com.test.spring.dao.UserDAO;

import com.test.spring.dao.UserDAOImpl;

import com.test.spring.model.User;

import com.test.spring.service.UserServiceImpl;

public class UserServiceImplTest {

    /**

     * @throws Exception

     * @Test 叫注解

     */

    public void testAdd() throws Exception {

        //ApplicationContext实现了生命周期

        ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");

        UserServiceImpl service = (UserServiceImpl)factory.getBean("userService");

        /**

         * 这里体现了IOC（控制反转）的思想，控制的是它的接口（抽象），

         * 而不是实现，容器里控制这它的实现

         */

        UserDAO userDAO = (UserDAO)factory.getBean("u");

        service.setUserDAO(userDAO);

        User u = new User();

        u.setPassword("zhangsan");

        u.setUsername("zhangsan");

        //这里体现了DI（依赖注入）的思想，将u中的容器中u的class注入到service这个bean中

        service.add(u);

    }

    @Test

    public void testProxy()

    {

        UserDAO userDAO = new UserDAOImpl();

        LogInterceptor li = new LogInterceptor();

        li.setTarget(userDAO);

        //li.setTarget(userDAO);

        //newProxyInstance(代理的对象的class，产生被代理对象实现的接口，处理)

        //由于它实现了UserDAO接口，所以强制转化成。。。

        UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), new Class[]{UserDAO.class},li);

        //userDAOProxy.delete();

        userDAOProxy.save(new User());

    }

}