Java框架技术：Spring的IOC使用

已于 2024-04-24 12:47:02 修改
阅读量833 收藏 29
点赞数 33
分类专栏： Java框架技术 文章标签： java spring 开发语言
于 2024-04-24 12:42:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/li3123537691/article/details/138155094
版权

实验目的：

  1. 掌握Spring的IOC操作，能够实现MVC层次的基于IOC的调用
  2. 掌握Spring的IOC的注解使用

实验内容：

在计算机上实现模拟查询学生成绩的操作，要求如下：

（1）构建User类和Student类，模拟数据库中的两个表，类属性如下:

A.Student类，属性（sid，sname，sex，age）

B.User，属性（uid，username，password）

（2）假设User类所对应的方法是login(username,password)和registry(username,password)完成该类中的这个方法在dao层的接口和实现类，以及service层的接口和实现类，注意，dao的实现类中，该登录方法的实现直接使用集合查询数据，注册方法直接往集合里面加入新用户即可，不用查询数据库，在service层的实现类则是直接调用dao层的方法即可；

（3）假设Student类所对应的方法是查询所有学生信息(List<Student> findStudent())以及根据id查询学生信息(Student findStudentById(int id))以及根据名字模糊查找学生信(List<Student> findStudentByName(String name))这三个方法，完成这三个方法在dao和service层的构建以及调用关系，实际student数据不用查数据库，我们直接在dao里面构建一个student的集合并自己初始化数据即可；

（4）提供JUnit单元测试，使用Scanner类来完成控制台的输入指令：1.用户登录，2.用户注册，3.退出，当用户登录成功之后，开始有新指令：1.查找所有学生、2.根据id查找学生、3.根据学生姓名查找学生；完成以上5个功能；

实现思路：

项目结构图：

1、引入先关依赖到 pom.xml中：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.spring</groupId>
    <artifactId>spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--Spring必备的支持包-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!--Spring-->
        <!--Spring的基础包Spring-core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Spring的基础包Spring-beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Spring的基础包Spring-context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Spring的基础包Spring-expression-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Spring的基础包Spring-aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-annotations-api</artifactId>
            <version>9.0.8</version>
        </dependency>
    </dependencies>


</project>
2、Spring IOC 的配置和实现
2.1：配置Spring的IOC容器

创建Spring配置文件applicationContext.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"
       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
	https://www.springframework.org/schema/context/spring-context.xsd">
    <!--将指定类配置给spring，让Spring创建User对象实例-->
    <context:component-scan base-package="com.spring"/>
</beans>
2.2：创建User类和Student类

创建User类，包含属性uid, username, password。

package com.spring.pojo;

import org.springframework.stereotype.Component;

@Component("user")
public class User {
    private int uid;
    private String username;
    private String password;

    public User(){

    }

    public User(int uid, String username, String password) {

        this.uid = uid;
        this.username = username;
        this.password = password;
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

创建Student类，包含属性sid, sname, sex, age。

package com.spring.pojo;

public class Student{
    private int sid;
    private String sname;
    private String sex;
    private int age;

    public Student(int sid,String sname,String sex,int age){
        this.sid=sid;
        this.sname=sname;
        this.sex=sex;
        this.age=age;
    }
    public Student() {

    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}
2.3：实现DAO层接口和实现类

创建UserDao接口，定义 login 和 registry 方法。

package com.spring.common.dao;

public interface UserDao {
    void login();

    void register();
}

创建UserDaoImpl实现类，实现 login 和 registry 方法，使用集合模拟数据库操作。

package com.spring.common.dao.Impl;

import com.spring.common.dao.UserDao;
import com.spring.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    User user;
    static List<User>userList = new ArrayList<User>();
    static User user1 = new User(1,"张三","123456");
    static Scanner sc = new Scanner(System.in);
    static int uid = 1;

    static {
        if(userList.isEmpty()){
            userList.add(user1);
        }
    }
    @Override
    public void login() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();

        for(User user:userList){

            if(username.equals(user.getUsername()) && password.equals(user.getPassword())){
                System.out.println("登录成功" + "\n");
                return;
            }
            else {
                System.out.println("用户名或密码错误" + "\n");
                return;
            }
        }
    }

    @Override
    public void register() {
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();
        uid += 1;
        User newUser = new User(uid,username,password);
        userList.add(newUser);
        System.out.println("注册成功" + "\n");
        for (User user:userList){
            System.out.println(user);
        }
    }
}

创建StudentDao接口，定义findStudent, findStudentById, findStudentByName方法。

package com.spring.common.dao;

public interface StudentDao {
    void FindStudent();

    void FindStudentById();

    void FindStudentByName();
}

创建StudentDaoImpl实现类，实现上述方法，使用集合模拟数据库操作并初始化数据。

package com.spring.common.dao.Impl;

import com.spring.common.dao.StudentDao;
import org.springframework.stereotype.Repository;
import com.spring.pojo.Student;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Repository("studentDao")
public class StudentDaoImpl implements StudentDao {
    Student student;
    static List<Student> studentList = new ArrayList<Student>();
    static  Student student1 = new Student(1,"萧炎","男",20);
    static  Student student2 = new Student(2,"林黛玉","女",18);
    static  Student student3 = new Student(3,"萧玄","男",22);
    static  Student student4 = new Student(4,"魂天帝","男",21);
    static  Student student5 = new Student(5,"林月如","女",20);
    static  Student student6 = new Student(6,"林青霞","女",25);
    static  Student student7 = new Student(7,"林长生","男",21);

    static {
        if (studentList.isEmpty()){
            studentList.add(student1);
            studentList.add(student2);
            studentList.add(student3);
            studentList.add(student4);
            studentList.add(student5);
            studentList.add(student6);
            studentList.add(student7);

        }
    }

    @Override
    public void FindStudent(){
        for(Student student:studentList) {
            System.out.println(student);
        }
    }

    @Override
    public void FindStudentById(){
        System.out.println("请输入您要查询的学生的id：");
        Scanner sc = new Scanner(System.in);
        int id = sc.nextInt();
        boolean flag = true;

        for(Student student:studentList) {

            if(id == student.getSid()) {
                System.out.println(student);
                flag = false;
                break;
            }
        }

        if(flag) {
            System.out.println("没有找到该学生");
        }

    }
    @Override
    public void FindStudentByName(){
        System.out.println("请输入您要查询的学生的姓名：");
        Scanner sc = new Scanner(System.in);
        String name = sc.next();
        Pattern pattern = Pattern.compile(name,Pattern.CASE_INSENSITIVE);
        for(Student student:studentList) {
            Matcher matcher = pattern.matcher(student.getSname());
            if(matcher.find()) {
                System.out.println(student);
            }
        }

    }

}
2.4：实现Service层接口和实现类

创建UserService接口，定义用户相关操作的方法。

package com.spring.service;

public interface UserService {
    void login();

    void register();
}

创建UserServiceImpl实现类，注入UserDao，实现业务逻辑。

package com.spring.service.Impl;

import com.spring.common.dao.UserDao;
import com.spring.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserDao userDao;

    @Override
    public void login(){
        this.userDao.login();
    }
    @Override
    public void register(){
        this.userDao.register();
    }
}

创建StudentService接口，定义学生信息相关操作的方法。

package com.spring.service;

public interface StudentService {
    void FindStudent();
    void FindStudentById();

    void FindStudentByName();
}

创建StudentServiceImpl实现类，注入StudentDao，实现业务逻辑。

package com.spring.service.Impl;

import com.spring.common.dao.StudentDao;
import com.spring.service.StudentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("studentService")
public class StudentServiceImpl implements StudentService {
    @Resource
    StudentDao studentDao;
    public void FindStudent() {
        this.studentDao.FindStudent();
    }
    @Override
    public void FindStudentById() {
        this.studentDao.FindStudentById();
    }
    @Override
    public void FindStudentByName() {
        this.studentDao.FindStudentByName();
    }

}
3、JUnit单元测试和Scanner输入指令
3.1：编写JUnit单元测试

编写SpringTest测试类，使用Spring的Test框架进行单元测试。

import com.spring.service.StudentService;
import com.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Scanner;

public class SpringTest {
    // 测试类
    public static void main(String[] args){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = ac.getBean("userServiceImpl", UserService.class);
        StudentService studentService = ac.getBean("studentService", StudentService.class);
        Scanner sc = new Scanner(System.in);
        System.out.println("请选择功能：");
        System.out.println("1.用户登录");
        System.out.println("2.用户注册");
        System.out.println("0.退出");
        int choice = sc.nextInt();

        switch (choice){
            case 1:
                System.out.println("************登录功能************");
                userService.login();
                Scanner sc1 = new Scanner(System.in);
                System.out.println("请选择功能：");
                System.out.println("1.查询所有学生信息");
                System.out.println("2.根据id查询学生信息");
                System.out.println("3.根据名字查找学生信息");
                int choice1 = sc.nextInt();

                switch (choice1){
                    case 1:
                        studentService.FindStudent();
                        break;
                    case 2:
                        studentService.FindStudentById();
                        break;
                    case 3:
                        studentService.FindStudentByName();
                        break;
                    default:
                        return;
                }

                break;

            case 2:
                System.out.println("************注册功能************");
                userService.register();
                break;
            default:
                System.out.println("************退出成功************");
                return;
        }
    }
}
3.2：实现控制台输入指令

用户登录功能和查找所有学生信息功能：

用户注册功能：

退出功能：

根据 id 查找学生：

根据名字查找学生：

【Java框架技术】Spring与Netty核心技术解析：IoC/AOP/事务管理及NIO通信框架应用详解
04-20
内容概要：本文详细介绍了Spring框架的核心概念和技术细节，包括BeanFactory和ApplicationContext的区别、Spring Bean的生命周期管理、IoC容器的实现原理、AOP的实现方式及其应用场景、事务管理的实现方式与底层原理...
【Java框架开发】手写简化版Spring框架：深入剖析IOC、AOP与Bean生命周期管理
最新发布
04-16
适合人群：具备一定编程基础，尤其是对Java有一定了解，希望深入了解Spring框架内部机制的研发人员。; 使用场景及目标：①理解工厂模式、策略模式、观察者模式等设计模式在Spring中的具体体现；②掌握IOC、AOP、代理...
Spring框架三、Spring IOC基本使用
吃透Java
03-20 365
一、spring对象的获取及属性赋值方式 People.java package com.bobo.bean; public class People { private int id; private String name; private int age; private boolean gender; public int getId() { ...
Java Spring IOC用法
weixin_30697239的博客
08-31 117
Java Spring IOC用法 Spring IoC 在前两篇文章中，我们讲了java web环境搭建 和 java web项目搭建,现在看下spring ioc在java中的运用，开发工具为Intellij Idea。 1.简介 IoC(Inversion of Control)通常称为控制反转，是Spring框架的核心。即通过Spring容器控制对象之间的依赖关系，而不是对象自己...
java spring ioc_java~spring-ioc的使用
weixin_30152861的博客
02-16 114
spring-ioc的使用IOC容器在很多框架里都在使用，而在spring里它被应用的最大广泛，在框架层面上，很多功能都使用了ioc技术，下面我们看一下ioc的使用方法。把服务注册到ioc容器使用属性注入反射对应类型的实例多态情况下，使用名称反射类型的实例把服务注册到ioc容器@Bean注册组件使用@Bean注解进行类型的注册，默认你的ioc容器里类型为bean的返回值，名称为bean所有的方法名...
Spring IOC使用
qq_42001445的博客
09-27 168
**Maven** 安装Maven，搭建环境变量 Maven获取jar包通过坐标定位：公司/组织(groupId)+项目名（artifactId）+版本(version) Maven仓库分为： 本地：自己的 <localRepository>路径 </localRepository> 私有：有的公司自己搭建自己的仓库 中央：默认国外，可以改成阿里的比较快 **配置：** 3层保险，默认中央仓库首选为阿里云，如果失败去外国仓库1找，还失败去外国2仓库找； <mirror&
Spring IoC 使用
时光
06-29 350
Spring IoC 使用
实验一：Spring IoC中Bean的装置的jar包
03-15
在Java开发领域，Spring框架是不可或缺的一个部分，它以其强大的依赖注入（IoC）和面向切面编程（AOP）功能而闻名。本实验聚焦于Spring IoC中的Bean装置，这是理解Spring框架核心机制的关键。我们将通过分析指定的...
SpringIOC：SpringIOC临时二进制简单实现
02-15
在这个"SpringIOC：SpringIOC临时二进制简单实现"中，我们将探讨如何在Java环境下构建一个简单的Spring IOC的二进制实现。 首先，理解控制反转的基本概念。在传统的编程模式中，对象通常自行创建依赖的对象，这导致...
mySpring:Spring IOC的模拟
05-09
在IT行业中，Spring框架是Java开发中的一个基石，特别是其Inversion of Control（IOC）容器，也就是我们常说的依赖注入（Dependency Injection）。本项目“mySpring:Spring IOC的模拟”旨在帮助开发者理解Spring IOC...
Spring中IOC的使用
Programer0的博客
04-07 234
IOC的使用 [1]责任链 使用MVC设计思想进行开发的时候，数据在各层之间进行传递，数据在业务上构成一个链条， 这个链条称之为责任链。 [2]基于责任链开发的缺点 基于责任链开发模式，我们发现代码层和层之间相互调用，造成了层和层的耦合性太高了。 而写代码的时候讲究的原则--低耦合、高内聚 [3] 解决的方案 Spring IOC : ...
Spring之IoC使用
zcg_741454897的博客
10-12 387
IOC简介 概念、优点网上一大堆，我只说下自己的见解。所谓控制反转IoC就是在开发过程中，不需要手动的new对象，而是把对象都交给Spring的IOC容器，由Spring容器来创建和注入到需要的相应对象的位置。 不使用SpringIoC的情况下举个例子：在传统的MVC模型中，用户Controller类会调用用户Service类，用户Service类调用用户Dao类，如果实现一个注册功能，需要有以下流程： Controller需要调用Service中的方法，所以Controller类中必须创建Service对
【JAVA-IOC(控制反转)】
ZERO_HOPE的博客
03-15 1907
5.1 IOC本质是个容器，本质上是对象工厂，通过读取配置文件，再通过它用反射来完成5.2 Spring提供的IOC容器的俩种实现方式（俩个接口）：IOC容器基本实现方式，Spring内部使用接口，一般不提供开发人员使用。特点：加载配置文件，不会去创建对象。在获取或使用对象时才创建对象。：可以理解成BeanFactory子接口，比BeanFactory更加强大。面向开发人员。特点：加载配置文件，就会去创建对象。一般使用第二种。定义一个接口创建一个实现了接口的类@Override。
2. spring IOC基本使用
hanzong110的博客
05-31 215
02spring IOC基本使用 ​ 通过前面的介绍我们已经知道了Spring中非常重要的一个特性就是IOC,下面我们将要来看一下如何使用IOC容器，帮助大家更好的体会spring的优势。 1、spring_helloworld (1)使用手动加载jar包的方式实现，分为三个步骤，现在几乎不用 repo.spring.io/release/org/springframework/spring/5.2.3.RELEASE，下载spring-5.2.3.RELEASE-dist.zip解压 导包：导入这五
Spring(三)-IOC使用
kesteler的博客
04-13 345
当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个。所以常用的是第2种方式，根据类型获取。
详解Spring IOC的使用
BugMan的博客
03-22 742
一文详解Spring IOC的使用
javaEE学习笔记9-21
qq_44102239的博客
09-21 171
9-21优化的工厂模式控制反转（IOC）Spring的IOCSpring管理bean对象创建Bean对象bean的作用范围bean的生命周期依赖注入使用构造函数注入set方法注入 优化的工厂模式 不加修改时，循环地调用工厂模式，将产生多个对象。这组对象将单独，独立地调用自己的方法。 工厂利用反射创建对象的语句： bean=Class.forName(beanPath).newInstance(); 由于使用了newInstance()，每次调用都必然调用默认构造函数，创建新对象。 使用单例对象，避免创建大
Spring IoC 快速使用入门
jason559的博客
01-21 177
目录一、启动 IoC 容器的方式：1、Java 环境下启动 IoC 容器：2、Web 环境下启动 IoC 容器：1）从 xml 启动容器；2）从配置类启动容器二、纯 xml 模式1、bean 对象的创建2、对象属性的依赖注入配置三、xml 与注解相结合模式1、注意2、xml 中标签与注解的对应（IoC）3、DI 依赖注入的注解实现方式1）@Autowired （推荐使用）2）@Resource3）注意：四、纯注解模式 一、启动 IoC 容器的方式： 1、Java 环境下启动 IoC 容器： ClassPa
Spring详解（二）Ioc的使用
weixin_41931278的博客
06-26 331
Ioc的概念和作用1.什么是程序的耦合2. 解决程序耦合的思路3.工厂模式解耦4.Ioc的概念和作用5.Ioc的实现方式 1.什么是程序的耦合 前面我们了解到通过 Spring提供的 IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造成的过度程序耦合。那么什么是程序的耦合呢？ 耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值