首页 > 软件编程 > java > Spring框架校园卡充值

利用Spring框架为自己的校园卡充值(推荐)

2022-10-06 10:08:04 作者：基础较差的cs菜鸟

这篇文章主要介绍了利用Spring框架为自己的校园卡充值,本次实验主要运用了Spring的控制反转（IOC）和依赖注入（DI）等知识，通过利用Spring框架编写Java程序，实现学生卡的单次充值，如需对学生卡进行多次充值，可将部分代码修改即可实现，需要的朋友可以参考下

实验要求：
在Dao层建立CardDao类，编写充值方法（save（）），实现充值（在控制台显示充值金额），在Biz层建立CardBiz类，编写充值方法（charge（）），调用Dao层中的充值方法（save（）），完成充值。充值金额在配置文件中输入（应用test中输入）。实现过程中不能利用new 操作来完成类的实例化（IoC容器）。

实验分析：

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

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

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

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

三个包下面分别建立三个类（class）即CardBiz、CardDao、StudentCard

代码实现：

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的人都会有自己的理解。这种概念上的理解没有绝对的标准答案，仁者见仁智者见智。如果有理解不到位或者理解错的地方，欢迎广大园友指正！

到此这篇关于利用Spring框架为自己的校园卡充值的文章就介绍到这了,更多相关Spring框架校园卡充值内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！