IOC入门1

1.配置文件

<?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>

2.bean实现

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;
    }
    
}

 

3.dao层接口实现

package com.test.spring.dao;

import com.test.spring.model.User;


public interface UserDAO {

    public void save(User u);
    
    public void delete();
}

4.dao层实现类实现

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!!!");
    }

}

5.service层接口编写

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);
}

6.service实现类实现

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);
    }
}

7json测试类编写

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());
        
    }

}

所用的包