Spring框架配置beans.xml

Spring学习笔记（一）

一、Spring 框架

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

Spring框架由七个模块组成:核心容器、应用上下文（Context）模块、Spring的AOP模块、JDBC抽象和DAO模块、对象/关系映射集成模块、Spring的Web模块、Spring的MVC框架。

介绍传送门-->http://baike.baidu.com/link?url=ZMgPopo8CSuxoq4cxxCjy600WLc07HP9K4ej4wI4Z07jpfyt82RlOk1MimelYU_tZwn9OyLE_dQVlXNzDm_Fba、

二、关于学习Spring框架之前自身的疑惑

1 Spring框架是如何对项目进行有效管理的?

三、学习开始

3.1 准备好Spring的说明书   http://docs.spring.io/spring/docs/

3.2 准备Spring的JAR包 spring-framework-3.0.0.RELEASE

3.3 先写一点测试代码（不使用Spring框架），然后再引入Spring框架进行管理，对比前后者代码的不同之处

测试代码逻辑:

1 UserServiceImpl调用 UserDao(接口) 完成对User对象的保存和更新

2 UserDao(接口) 有两种实现UserDaoImpl和UserDaoImpl2 

UserServiceImpl

 package com.serviceImpl;

 import com.dao.UserDao;
 import com.daoImpl.UserDaoImpl;
 import com.entity.User;

 public class UserServiceImpl {
     private UserDao userDao;

     public void add(User user) {
         userDao = new UserDaoImpl(); //UserDaoImpl实现接口
         userDao.save(user);
     }

     public void modify(User user) {
         userDao = new UserDaoImpl();//UserDaoImpl实现接口
         userDao.update(user);
     }

     public UserDao getUserDao() {
         return userDao;
     }
     public void setUserDao(UserDao userDao) {
         this.userDao = userDao;
     }
 }

UserDao（接口）

package com.dao;

import com.entity.User;

public interface UserDao {
    public void save(User user);
    public void update(User user);
}

UserDao的实现类UserDaoImp

 package com.daoImpl;

 import com.dao.UserDao;
 import com.entity.User;

 public class UserDaoImpl implements UserDao{

     public void save(User user) {
         System.out.println(user.getName()+"-->"+user.getRemark()+"  save --调用UserDaoImpl!");
     }

     public void update(User user) {
         System.out.println(user.getName()+"-->"+user.getRemark()+"  update --调用UserDaoImpl!");
     }
 }

UserDao的另一个实现类UserDaoImpl2

package com.daoImpl;

import com.dao.UserDao;
import com.entity.User;

public class UserDaoImpl2 implements UserDao{

    public void save(User user) {
        System.out.println(user.getName()+"-->"+user.getRemark()+"  save --调用UserDaoImpl2!");
    }

    public void update(User user) {
        System.out.println(user.getName()+"-->"+user.getRemark()+"  update  --调用UserDaoImpl2!");
    }
}

最后给一个测试类（方便使用）

package com.serviceImpl.test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

import com.entity.User;
import com.serviceImpl.UserServiceImpl;

public class UserServiceImplTest {
    User user;

    @Before
    public void setUp() throws Exception {
        user = new User();
        user.setName("testName");
        user.setRemark("testRemark");
    }

    @Test
    public void testAdd() {
         UserServiceImpl userServiceImpl = new UserServiceImpl();
         userServiceImpl.add(user);
    }

    @Test
    public void testModify() {
         UserServiceImpl userServiceImpl = new UserServiceImpl();
         userServiceImpl.modify(user);
    }
}

测试代码完成（未使用Spring框架）。

执行结果：

testName-->testRemark save --调用UserDaoImpl!
testName-->testRemark update --调用UserDaoImpl!

以上代码及执行结果可以看出

1 UserDao接口的实现方式是通过UserServiceImpl类里的代码管理的。

2 如果我们需要改变UserDao接口的实现方式则需要改动UserServiceImpl的代码 例如

userDao = new UserDaoImpl(); ----> userDao = new UserDaoImpl2(); //UserDaoImpl改成UserDaoImpl2

3.4 使用Spring框架进行管理

1 导入spring JAR包

2 在src目录下创建Beans.xml，剪切spring说明书中的basic structure of XML-based configuration metadata代码，粘贴进Beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="..." class="...">
    <!-- collaborators and configuration for this bean go here -->
  </bean>

  <bean id="..." class="...">
    <!-- collaborators and configuration for this bean go here -->
  </bean>

  <!-- more bean definitions go here -->

</beans>

3 对应于我们的项目开始进行Beans.xml的详细配置（目前写的Beans.xml 里对接口的注入是通过set方法，是Spring 注入的一种，随后会详细介绍）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

  <!--Spring框架beans.xml配置文件的基础:一个bean和一个对应的类,然后对bean进行统一的管理 -->

  <!--userDao的第一种实现方法映射的 bean -> userDaoImpl-->
  <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
  </bean>

   <!--userDao的第二种实现方法映射的 bean -> userDaoImpl2-->
  <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
  </bean>

   <!--UserServiceImpl映射的 bean -> userServiceImpl-->
   <!--在这个bean里 我们来配置userDao的实现类对应的bean，引入property标签。
     1 name对应当前bean（类）里面的变量名   private UserDao userDao;
     2 ref表示所关联是哪个bean。 这里我们关联上userDaoImpl2也就是第二种实现方式 class="com.daoImpl.UserDaoImpl2"；
     3 完成1，2后，我们可以去把com.serviceImpl.UserServiceImpl文件里，原本在代码里NEW 出实现类的那段话给去掉，spring已经开始进行管理了。
   -->
  <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl">
      <property name="userDao" ref="userDaoImpl"> </property>
  </bean>
</beans>

4 删除UserServiceImpl类里对接口实现方式控制的代码

package com.serviceImpl;

import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.entity.User;

public class UserServiceImpl {
    private UserDao userDao;

    public void add(User user) {
//        userDao = new UserDaoImpl(); //已经不需要我们在程序里面再NEW实现类了
        userDao.save(user);
    }

    public void modify(User user) {
//        userDao = new UserDaoImpl();//已经不需要我们在程序里面再NEW实现类了
        userDao.update(user);
    }

    public UserDao getUserDao() {
        return userDao;
    }
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

5 已经完成了Spring的配置，现在对测试文件UserServiceImplTest进行修改，执行查看效果

package com.serviceImpl.test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.entity.User;
import com.serviceImpl.UserServiceImpl;

public class UserServiceImplTest {
    User user;

    @Before
    public void setUp() throws Exception {
        user = new User();
        user.setName("testName");
        user.setRemark("testRemark");
    }

    @Test
    public void testAdd() {
         ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");//通过ClassPathXmlApplicationContext获取beans.xml信息-->app
         UserServiceImpl UserServiceImpl = (UserServiceImpl)app.getBean("userServiceImpl");//通过app NEW出具体bean对应的类，注意需要转换类型
         UserServiceImpl.add(user);//调用方法
    }

    @Test
    public void testModify() {
         ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
         UserServiceImpl UserServiceImpl = (UserServiceImpl)app.getBean("userServiceImpl");
         UserServiceImpl.modify(user);
    }
}

6 执行结果（UserDao接口的实现为bean里配置的userDaoImpl）

testName-->testRemark  save --调用UserDaoImpl2!

testName-->testRemark  update  --调用UserDaoImpl2!

7 如果要更换UserDao的实现，有了spring进行管理，我们只要去对beans.xml进行修改即可

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
  </bean>

  <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
  </bean>

  <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl">
 <property name="userDao" ref="userDaoImpl"> </property>    <!--  修改 ref="userDaoImpl"-->
  </bean>
</beans>

8 再次查看执行的结果（UserDao接口的实现已经更换成userDaoImpl）

testName-->testRemark  save --调用UserDaoImpl!

testName-->testRemark  update --调用UserDaoImpl!

9 到此，Spring的部署及简单应用已经完成。

总结一下

1 Spring 是通过配置beans.xml 来对类和接口进行管理

2 具体的操作:

一 配置beans.xml  并删除代码里原本用来管理接口实现的代码

二 改写调用的方法 ClassPathXmlApplicationContext("xmlProfile").getBean("beanName");

3 对比原先的测试代码与用了Spring管理的后测试代码

一 程序的扩展性变强，只需要通过配置文件便可以进行管理，例如修改接口的实现方式变得非常简单。

二 程序的可阅读性提高，不需要进入代码层面进行阅读接口实现的方式，只需要在配置文件中查看即可。