[Java知识库]利用Spring框架为自己的校园卡充值。

实验分析：

1. 建立CardDao类，在此类下编写方法save（），以实现充值（在控制台显示充值金额）；
2. 建立StudentCard类，在此类下定义余额，以此记录并获取学生卡里的余额；
3. 建立CardBiz类，在此类下编写方法charge（），以实现将方法save（）里的充值金额与学生卡里的余额相加，获得充值后的金额。
4. 题目要求不能使用new来完成对类的实例化，应采用配置文件进行操作，即本章内容IOC容器（控制反转），其中还会用到DI（依赖注入）。

实验操作所用工具（软件）：
IntelliJ IDEA 2021.2.1

实验需要建立三层结构，分别是：Dao层、Biz层、Entity层。

以此建立三层结构。即在工程文件下的src文件夹的main中的Java建立三个包（package）。在resource下编写配置文件。
在工程文件下的src文件夹的test中的Java建立test类。
效果如图：

代码实现：

CardDao类

package com.cqust.dao;

import com.cqust.entity.StudentCard;

public class CardDao {
    public void save(double money){
        System.out.println("您的充值金额为：￥" + money);
    }
}

StudentCard类

package com.cqust.entity;

public class StudentCard {
    double balance;         //定义余额

    public double getBalance() {
        return balance;     //返回余额
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

CardBiz类

package com.cqust.biz;

import com.cqust.dao.CardDao;
import com.cqust.entity.StudentCard;

public class CardBiz {
    private StudentCard studentCard;	//定义一个StudentCard对象
    private CardDao cardDao;			//定义一个CardDao对象
    public void setStudentCard(StudentCard studentCard) {
        this.studentCard = studentCard;
    }
    public void setCardDao(CardDao cardDao) {
        this.cardDao = cardDao;
    }
    public void charge(double money){
        cardDao.save(money);        					//调用cardDao里的save方法
        double sum = studentCard.getBalance() + money;	//将学生卡里的余额加上需要充值的金额
        System.out.println("充值成功！当前您的余额为：￥" + sum);	//输出充值后的金额
    }
}

test类（src\test\java\test.java）

import com.cqust.biz.CardBiz;
import com.cqust.entity.StudentCard;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    public static void main(String[] args) {
        //获取核心容器(IoC)对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取xml文件中的bean
        CardBiz cardBiz= (CardBiz) applicationContext.getBean("cardBiz");
        //获取xml文件中的bean
        StudentCard studentCard= (StudentCard) applicationContext.getBean("studentCard");
        //传一个数值给cardBiz里的charge方法进行充值，此处我给的800，吃好一点哈哈哈
        cardBiz.charge(800);
    }
}

applicationContext.xml（配置文件）

< property >是< bean >元素的子元素，它用于调用Bean实例中的setXXX()方法完成属性赋值，从而实现依赖注入，其name属性表示Bean实例中的相应属性名，ref属性用于表示指定其属性值。

<?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="studentCard" class="com.cqust.entity.StudentCard">
        <property name="balance" value="88.88"></property>      <!--将学生卡的余额设置为88.8元-->
    </bean>
    <bean id="cardDao" class="com.cqust.dao.CardDao"></bean>
    <bean id="cardBiz" class="com.cqust.biz.CardBiz">
        <property name="studentCard"  ref="studentCard"></property>
        <property name="cardDao" ref="cardDao"></property>
    </bean>
</beans>

程序运行结果：

实验总结：
　　本次实验主要运用了Spring的控制反转（IOC）和依赖注入（DI）等知识，通过利用Spring框架编写Java程序，实现学生卡的单次充值。如需对学生卡进行多次充值，可将部分代码修改即可实现。
　　在传统Java开发下，调用者会采用“new 被调用者”的代码方式来创建被调用者这个需要使用的对象。而使用Spring框架，被调用者只需要让spring容器来创建。从spring的角度来看，仅仅是进行了依赖注入（DI）；从项目的角度来看，控制权从应用代码转移到了spring容器，发生了控制反转（IOC），所以说依赖注入和控制反转只是从两个角度描述了同一个概念。IOC的概念更广，使用了DI的程序一定使用了IOC，但是使用了IOC的程序不一定使用了DI。
IoC(控制反转)
　　首先想说说IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。
　　那么IoC是如何做的呢？Spring所倡导的开发方式就是，所有的类都会在spring容器中登记，告诉spring你是个什么，你需要什么，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
DI(依赖注入)
　　IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象H需要操作数据库，以前我们总是要在H中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，H中需要一个Connection，至于这个Connection怎么构造，何时构造，H不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注入到H当中，这样就完成了对各个对象之间关系的控制。H需要依赖 Connection才能正常运行，而这个Connection是由spring注入到H中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。
　　理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作就是在spring的框架中堆积木啦。
　　对于Spring IoC这个核心概念，我相信每一个学习Spring的人都会有自己的理解。这种概念上的理解没有绝对的标准答案，仁者见仁智者见智。如果有理解不到位或者理解错的地方，欢迎广大园友指正！
　　
谢谢浏览！