Spring系列教程六： Spring基於註解的Ioc以及Ioc案例

時間 2019-11-10

標籤 spring 系列教程基於註解 ioc 以及案例欄目 Spring 简体版

原文原文鏈接

學習基於註解的Ioc配置，咱們腦海中須要有一個認知，就是註解配置和xml配置實現的功能都是同樣的，都是要下降程序間的耦合，只是配置的形式不同java

在實際開發中究竟是使用xml仍是註解，每一個公司有不一樣的使用習慣，全部這兩種配置方式咱們都須要掌握mysql

咱們在講解註解配置時，採用上一章的案例，把Spring的xml配置內容改成使用註解逐步實現spring

一、Spirng中Ioc的經常使用註解按照做用分類

用於建立對象:做用是和xml配置文件中編寫一個bean標籤建立對象的功能是同樣的

@Component(如下三個是Spring框架爲咱們明確提供的三層使用註解，使咱們的三層對象更加清晰，如下是Component的衍生類)sql

Controller(這個對象通常用在表現層)數據庫

Service(這個對象一遍用於業務層)apache

Repository(這個業務通常用於持久層)
做用：把當前對象存入Spring容器中
屬性：value 用於指定bean的id,當咱們不寫的時候，它的默認是當前類名，且首字母小寫，也能夠指定一個名稱app

①在接口中實現@Component的代碼改寫

@Component("accountServiceImpl4")
public class AccountServiceImpl4 implements IAccountService {

   private String name;
   private Integer age;
   private Date brithday;

   AccountServiceImpl4(String name, Integer age, Date brithday){
       this.name=name;
       this.age=age;
       this.brithday=brithday;
   }

   public void saveAccount(){
       System.out.println("service中的saveAccount方法執行了...."+name+age+brithday);
   }
}

②配置文件中改寫(須要新添加引入context的約束)

<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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx">
    <!--新添加一個約束：告訴Spring在建立容器時要掃描的包，配置所須要的標籤不是在bean的約束中，而是一個名稱爲
    context的名稱和空間中,這個時候就會掃描base-pack類上或者接口上的註解-->
    <context:component-scan base-package="com.ithema.jdbc"></context:component-scan>
</beans>

③測試類框架

package com.ithema.jdbc.ui;
import com.ithema.jdbc.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模擬一個表現層，用於調用業務層
 */
public class Client2 {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("ApplicationContext2.xml");
        IAccountService as= (IAccountService) ac.getBean("accountServiceImpl4");
        System.out.println(as);
        as.saveAccount();
    }
}

顯示結果以下ide

用於注入數據:做用是和xml配置文件中編寫一個property標籤建立對象的功能是同樣的

Autowired單元測試

做用：自動按照類型注入，主要容器中有惟一一個bean對象和要注入的變量類型匹配，就能夠注入成功，若是Ioc容器中沒有任何bean類型和要注入的變量類型匹配，則報錯

若是有Ioc容器中有多個匹配類型：首先按照類型圈定出來匹配的對象，使用變量名稱做爲bean的id，在圈定出來的兩個裏面繼續查找，若是bean id有同樣也能夠注入成功

出現位置：能夠是變量上，也能夠是方法上

細節：在使用註解注入時候，set方法就不用了

可是這種狀況不是咱們想看到的，那麼有新的方法嗎？？以下

Qualifier(不能獨立使用，須要和Autowired配合使用，有解決的方案嗎？以下一個屬性)

做用：在按照類中注入的基礎上再按照名稱注入，它在給類成員注入時，不能單獨使用，但在給方法參數注入時候能夠

屬性：value 用於指定bean的id

Resource:直接按照bean的id注入，平時用的比較多，它能夠獨立使用

@Resource(name="accountDao")

以上三個註解只能注入其餘bean類型的數據，而基本數據類型和String類型沒法使用上述註解實現，另外，集合類型的注入只能使用xml來實現，怎麼解決以下

Value:

做用：涌入注入基本類型和String類型的數據

屬性 value:用於指定數據的值，它可使用Spring中spel(也就是Spring中的el表達式)，spel寫法$(表達式)

①接口上修改代碼

②啓動測試類顯示結果以下，成功注入數據

存在一bean對象時候

存在多個bean對象時候，要注入的變量名稱和某個bean的id保持一致也能夠注入成功

用於改變做用範圍:他們的做用是和xml配置文件中編寫一個scope標籤的功能是同樣的

做用：用於指定bean的做用範圍，屬性：value 指定範圍取值，經常使用取值singleton(默認值)/prototype

測試以下，做用範圍默認是單例的

那麼若是咱們把做用範圍改爲prototype的啦？結果固然是false

和生命週期相關：他們的做用是和xml配置文件中編寫一個init-method和destory-method標籤的功能是同樣的

PreDestory 做用：用於指定銷燬方法

PostConstruct 做用：初始化方法

二、使用xml方式和註解方式實現單表的CURD操做，持久技術層選用dbutils(案例)

項目目錄

StudentDao方法接口

package com.it.dao;

import com.it.entity.Student;

import java.util.List;

public interface StudentDao {

    List<Student> findAllStudent();

    Student findByid(int id);

    void saveStudent(Student student);

    void updateStudent(Student  student);

    void deleteStudent(int id);
}

StdentDao接口實現類

package com.it.dao;

import com.it.entity.Student;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository("StudentDao")
public class StudentDaoImpl implements StudentDao {

    @Autowired
    private  QueryRunner runner;

    @Override
    public List<Student> findAllStudent() {
        //BeanListHandler將結果集中的每一行數據都封裝到一個對應的JavaBean實例中，存放到List裏
        try{
            return runner.query("select * from student",new BeanListHandler<Student>(Student.class));
        }catch (Exception e){
            throw  new RuntimeException(e);
        }

    }

    @Override
    public Student findByid(int id) {
        //BeanHandler：將結果集中的第一行數據封裝到一個對應的JavaBean實例中
        try{
            return runner.query("select * from student where id=?",new BeanHandler<Student>(Student.class),id);
        }catch (Exception e){
            throw  new RuntimeException(e);
        }
    }

    @Override
    public void saveStudent(Student student) {
        try{
            runner.update("insert into student(id,stuno,name,classid)values(?,?,?,?)",student.getId(),student.getStuno(),student.getName(),student.getClassid());
        }catch (Exception e){
            throw  new RuntimeException(e);
        }

    }

    @Override
    public void updateStudent(Student student) {
        try{
            runner.update("update student set stuno=?,name=?,classid=? where id=?",student.getStuno(),student.getName(),student.getClassid(),student.getId());
        }catch (Exception e){
            throw  new RuntimeException(e);
        }

    }

    @Override
    public void deleteStudent(int id) {
        try{
            runner.update("delete from student where id=?",id);
        }catch (Exception e){
            throw  new RuntimeException(e);
        }

    }
}

Service層方法接口

package com.it.service;

import com.it.entity.Student;

import java.util.List;


public interface StudentService {
    /**
     * 查找全部學生
     * @return
     */
    List<Student> findAllStudent();

    /**
     * 根據id查找學生
     */
    Student findByid(int id);
    /**
     * 保存操做
     */
    void saveStudent(Student student);
    /**
     * 更新操做
     */
    void updateStudent(Student  student);
    /**
     * 刪除操做
     */
    void deleteStudent(int id);
}

Service層接口實現類，這裏就是用了注入的方式給StudentDao注入參數

package com.it.service;

import com.it.dao.StudentDao;
import com.it.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("studentService")
public class StudentServiceImpl implements  StudentService{

    @Autowired
    private StudentDao studentDao;

    @Override
    public List<Student> findAllStudent() {

        return studentDao.findAllStudent();
    }

    @Override
    public Student findByid(int id) {

        return studentDao.findByid(id);
    }

    @Override
    public void saveStudent(Student student)
    {
       studentDao.saveStudent(student);
    }

    @Override
    public void updateStudent(Student student) {

        studentDao.updateStudent(student);
    }

    @Override
    public void deleteStudent(int id) {

        studentDao.deleteStudent(id);
    }
}

學生的實體類

package com.it.entity;

import java.io.Serializable;

/**
 * 學生實體類
 */
public class Student implements Serializable {

    private int id;
    private String stuno;
    private String name;
    private int classid;

    public int getId() {

        return id;
    }

    public void setId(int id) { this.id = id; }

    public String getStuno() {
        return stuno;
    }

    public void setStuno(String stuno) {
        this.stuno = stuno;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getClassid() {
        return classid;
    }

    public void setClassid(int classid) {
        this.classid = classid;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", stuno='" + stuno + '\'' +
                ", name='" + name + '\'' +
                ", classid=" + classid +
                '}';
    }
}

父配置類，指定當前類爲註解類的標籤，Configuration

package com.it.config;

import org.springframework.context.annotation.*;

@Configuration
@Import(JbdcConfig.class)
@ComponentScan("com.it")
@PropertySource("classpath:JdbcConfig.properties")
public class SpringConfiguration {

}

子配置類，主要是配置的鏈接jdbc的數據庫

package com.it.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;

public class JbdcConfig {
    /**
     * 建立dataSource對象
     * @param dataSource
     * @return
     */
    @Value("${jdbc.driver}")
    private  String driver;
    @Value("${jdbc.url}")
    private  String url;
    @Value("${jdbc.username}")
    private  String username;
    @Value("${jdbc.password}")
    private  String password;

    @Bean("runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 建立數據源對象
     */
    @Bean("dataSource")
    public DataSource createDataSource() {
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return  ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

下面是配置文件

<?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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--告訴Spring容器在建立的時候要掃描包，配置所須要的標籤不在bean約束中，而是
    在一個叫作context的空降名稱和約束中-->
    <context:component-scan base-package="com.it"></context:component-scan>
    <!--配置QuerryRunner對象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入數據源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置數據-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/fresh?characterEncoding=UTF-8"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

數據庫配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/fresh?characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=root

日誌輸出文件配置，主要是配置輸出到控制檯

log4j.rootLogger=info,CONSOLE

#############################################################
# Console Appender
#############################################################
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=info
##log4j.appender.CONSOLE.DatePattern=yyyy-MM-dd
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-M-d HH:mm:ss}%x[%4p]:%m%n'
##輸出到文件

##添加到數據庫

最後是測試類，這裏咱們採用了spring整合junit4的方式

package com.it;

import com.it.config.SpringConfiguration;
import com.it.entity.Student;
import com.it.service.StudentService;
import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;


/**
 * **
 *  * 使用Junit單元測試：測試咱們的配置
 *  * Spring整合junit的配置
 *  *      一、導入spring整合junit的jar:spring-test(座標)
 *  *      二、使用Junit提供的一個註解把原有的main方法替換了，替換成spring提供的
 *  *             @Runwith
 *  *      三、告知spring的運行器，spring和ioc建立是基於xml仍是註解的，而且說明位置
 *  *          @ContextConfiguration
 *  *                  locations：指定xml文件的位置，加上classpath關鍵字，表示在類路徑下
 *  *                  classes：指定註解類所在地位置
 *  *
 *  *   當咱們使用spring 5.x版本的時候，要求junit的jar必須是4.12及以上
 *  */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class TestClient {
    Logger logger=Logger.getLogger(TestClient.class);
    @Autowired
    private  StudentService as;
    @Test
    public  void findAll(){
        List<Student> studentList =as.findAllStudent();
        for (Student student:studentList) {
            //System.out.println(student);
            logger.info(student);
        }
    }

    @Test
    public  void findbyidtest() {
        //ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Student student = as.findByid(4);
        logger.info(student);
    }

    @Test
    public  void saveTest() {
        Student student=new Student();
        student.setId(7);
        student.setStuno("10007");
        student.setName("陳多糖");
        student.setClassid(2);
        as.saveStudent(student);
    }
    @Test
    public  void updatetest() {
        Student student = as.findByid(4);
        student.setName("陳柳柳");
        as.updateStudent(student);
    }

    @Test
    public  void deletetest() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        StudentService as = ac.getBean("studentService", StudentService.class);
        as.deleteStudent(7);
    }
}

輸出結果以下

三、改造基於註解的Ioc案例，使用註解的方式實現Spring的一些新註解的使用

如何實如今不是咱們本身寫類上的註解，好比咱們引入QueryRunner類

基於註解的 IoC 配置已經完成，可是你們都發現了一個問題：咱們依然離不開 spring 的 xml 配置文件，那麼能不能不寫這個 bean.xml，全部配置都用註解來實現呢？固然，咱們們也須要注意一下，咱們選擇哪一種配置的原則是簡化開發和配置方便，而非追求某種技術。

①先建立一個config文件，裏面建立一個Springconfiguration的類

package com.it.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
@Configuration
@ComponentScan("com.it")
public class SpringConfiguration {
    /**
    *建立一個QueryRunner對象
    */
    @Bean("runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 建立數據源對象
     */
    @Bean("dataSource")
    public DataSource createDataSource() {
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/fresh?characterEncoding=UTF-8");
            ds.setUser("root");
            ds.setPassword("root");
            return  ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Configuration
* 做用：指定當前類是一個配置類
* 細節：當配置類做爲AnnotationConfigApplicationContext對象建立的參數時，該註解能夠不寫

ComponentScan
* 做用：用於經過註解指定spring在建立容器時要掃描的包
* 屬性：
* value：它和basePackages的做用是同樣的，都是用於指定建立容器時要掃描的包。
* 咱們使用此註解就等同於在xml中配置了:
* <context:component-scan base-package="com.itheima"></context:component-scan>

Bean
* 做用：用於把當前方法的返回值做爲bean對象存入spring的ioc容器中，該註解只能寫在方法上
* 屬性:
* name:用於指定bean的id，當不寫時，默認值是當前方法的名稱
* 細節：
* 當咱們使用註解配置方法時，若是方法有參數，spring框架會去容器中查找有沒有可用的bean對象。
* 查找的方式和Autowired註解的做用是同樣的

②測試類文件中的改寫

package com.it;

import com.it.config.SpringConfiguration;
import com.it.entity.Student;
import com.it.service.StudentService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class TestClient {
    @Test
    public  void findAll(){
        //ApplicationContext ac= new ClassPathXmlApplicationContext("ApplicationContext.xml");
        ApplicationContext ac= new AnnotationConfigApplicationContext(SpringConfiguration.class);
        StudentService as = ac.getBean("studentService",StudentService.class);
        List<Student> studentList =as.findAllStudent();
        for (Student student:studentList) {
            System.out.println(student);
        }
    }
}

測試結果以下：

問題來了，上面劃線的部分兩個的做用是同樣的嘛？效果是不同的，下面劃線部分，當把對象建立好了後，會把對象給你丟到Spring Ioc容器中，上面劃線的部分固然不會那麼作，它只是會給你返回一個QueryRunner的對象，這個時候就須要咱們手動把對象丟到容器裏面去，就須要採用@Bean的方法

QueryRunner對象是否是一個單例對象

線面還有一個問題就是咱們的QueryRunner對象是否是一個單例對象啦？這個問題關係到咱們線程的問題

那怎麼改變bean的做用範圍啦？這個是時候寄須要用的scope屬性啦，結果以下

父配置類導入子配置類用@Import

對於配置類咱們想要把SpringConfiguration中的jbdc配置專門提取到一個配置類中去?這樣的話也方便後期的管理和修改

單元測試findAll的測試結果以下

導入配置perproties配置文件@PropertySource
* 做用：用於指定properties文件的位置
* 屬性：
* value：指定文件的名稱和路徑。
* 關鍵字：classpath，表示類路徑下
*

在以前JdbcConfig配置類中dataSource的全部的屬性都是寫死的後來咱們進行了以下改造

package com.it.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;

public class JbdcConfig {
    /**
     * 建立dataSource對象
     * @param dataSource
     * @return
     */
    @Value("${jdbc.driver}")
    private  String driver;
    @Value("${jdbc.url}")
    private  String url;
    @Value("${jdbc.username}")
    private  String username;
    @Value("${jdbc.password}")
    private  String password;

    @Bean("runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 建立數據源對象
     */
    @Bean("dataSource")
    public DataSource createDataSource() {
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return  ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

對於新建立的private String driver屬性，咱們使用@Valeue("${jdbc.diver}")來注入perproties中的值，在SpringConfigruation配置父類中使用@PropertySource來注入配置文件

測試結果以下，同樣能查詢到結果

那麼咱們通常適合用那種配置方式？用註解仍是，xml啦？

用到已經寫好的jar的，通常狀況下咱們用xml來配置，比較省事，要是這個類是咱們本身寫的話，用註解來配置比較方便

四、Spring和Junit的整合

在咱們的測試類中存在不少的重複的方法，那麼有沒方法解決啦！！我先採用init的方式先加載建立容器的方式

結果顯示沒有任何問題，那麼這個問題被完全解決掉了嘛？

根據分析獲得，junit運行原理

使用Junit單元測試：測試咱們的配置，Spring整合junit的配置
一、導入spring整合junit的jar:spring-test(座標)
二、使用Junit提供的一個註解把原有的main方法替換了，替換成spring提供的@Runwith
三、告知spring的運行器，spring和ioc建立是基於xml仍是註解的，而且說明位置
@ContextConfiguration
屬性：locations：指定xml文件的位置，加上classpath關鍵字，表示在類路徑下
classes：指定註解類所在地位置
細節：當咱們使用spring 5.x版本的時候，要求junit的jar必須是4.12及以上

package com.it;

import com.it.config.SpringConfiguration;
import com.it.entity.Student;
import com.it.service.StudentService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class TestClient {
    @Autowired
    private  StudentService as;
    @Test
    public  void findAll(){
        List<Student> studentList =as.findAllStudent();
        for (Student student:studentList) {
            System.out.println(student);
        }
    }

    @Test
    public  void findbyidtest() {
        //ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Student student = as.findByid(4);
        System.out.println(student);
    }

    @Test
    public  void saveTest() {
        Student student=new Student();
        student.setId(7);
        student.setStuno("10007");
        student.setName("陳多糖");
        student.setClassid(2);
        as.saveStudent(student);
    }
    @Test
    public  void updatetest() {
        Student student = as.findByid(4);
        student.setName("陳柳柳");
        as.updateStudent(student);
    }

    @Test
    public  void deletetest() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        StudentService as = ac.getBean("studentService", StudentService.class);
        as.deleteStudent(7);
    }
}

測試結果以下：

爲何不把測試類配到 xml

在解釋這個問題以前，先解除你們的疑慮，配到 XML 中能不能用呢？答案是確定的，沒問題，可使用。那麼爲何不採用配置到 xml 中的方式呢？這個緣由是這樣的：第一：當咱們在 xml 中配置了一個 bean，spring 加載配置文件建立容器時，就會建立對象。第二：測試類只是咱們在測試功能時使用，而在項目中它並不參與程序邏輯，也不會解決需求上的問題，因此建立完了，並無使用。那麼存在容器中就會形成資源的浪費。因此，基於以上兩點，咱們不該該把測試配置到 xml 文件中。