第三章 SpringIOC容器的使用

已于 2024-04-16 08:07:28 修改
阅读量1.2k 收藏 19
点赞数 49
分类专栏： spring 文章标签： spring
于 2024-04-09 23:04:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnsqls/article/details/137571524
版权

第三章 SpringIOC容器的使用

一 SpringIOC容器的实现步骤

1. 编写元数据（配置）

既是编写交给SpringIoC容器管理组件的信息，配置方式有三种。xml，注解以及配置类。

以下是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
    https://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="..." [1] class="..." [2]>  
    <!-- 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>

标签 == 组件信息声明

  • id 属性是标识单个 Bean 定义的字符串。

  • class 属性定义 Bean 的类型并使用完全限定的类名。

2. 创建IOC容器

即实例化IOC容器，有四种实现类，ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,AnnotationConfigApplication,WebApplicationContext前面已经介绍。

以下是用ClassPathXmlApplicationContext 类实例化IOC容器

//实例化ioc容器,读取外部配置文件,最终会在容器内进行ioc和di动作
ApplicationContext context = 
           new ClassPathXmlApplicationContext("services.xml", "daos.xml");

3. 通过IOC容器获得组件

ApplicationContext 是一个高级工厂的接口，能够维护不同 bean 及其依赖项的注册表。通过使用方法 T getBean(String name, Class<T> requiredType) ，您可以检索 bean 的实例。

允许读取 Bean 定义并访问它们，如以下示例所示：

//创建ioc容器对象，指定配置文件，ioc也开始实例组件对象
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
//获取ioc容器的组件对象
PetStoreService service = context.getBean("petStore", PetStoreService.class);
//使用组件对象
List<String> userList = service.getUsernameList();

二 XML配置方式管理组件

2.1 组件(bean)的注册

使用xml配置注册组件(bean)思路:

  1. 准备好自定义的类
  2. 导入spring依赖
  3. 编写元数据配置bean

具体实现:

  1. 准备项目

a.创建maven工程

b.导入springIOC相关依赖

pom.xml

  <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>
  1. 对于无参构造器bean的注册

a. 自定义java类

public class Component {
    public Component() {
    }
}

b. 编写配置文件 resource/xxx.xml

首先添加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">

</beans>

在idea中约束可以自动生成,如下图(前提是已经导入了spring-context依赖)

c.在spring配置文件中编写标签注册bean

 <bean id="component" class="com.ls.ioc_01.Component"/>

2.2 组件(bean)的依赖注入

通过配置文件,实现IOC容器中bean的赋值已经引用(依赖注入DI),有两种场景,基于构造函数依赖注入,和基于setter依赖注入

思路

2.2.1基于构造函数的依赖注入

A. 单个构造参数注入

准备组件

public class UserDao {
}


public class UserService {
    
    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

添加spring约束编写配置bean

<?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">

<!--    基于构造器进行依赖注入（单个参数）-->
<!--    首先要确保两个组件都要在[ioc]容器中
         在需要进行DI的组件中 用<constructor-arg>标签来赋值
                    ref ： 引用ioc中其他组件    其他bean的id
                    value： 就是普通值
 -->
<!--    tips： 组件的先后顺序无所谓，因为ioc容器会先创建组件，然后在赋值（DI）-->

    <bean id="userDao" class="com.ls.ioc_02.UserDao"/>
    <bean id="userService" class="com.ls.ioc_02.UserService">
        <constructor-arg ref="userDao"/>
    </bean>
</beans>
B 多个构造参数注入

准备组件

public class UserDao {
}

public class UserService {
    private UserDao userDao;
    private int age;
    private String name;

    public UserService(UserDao userDao, int age, String name) {
        this.userDao = userDao;
        this.age = age;
        this.name = name;
    }
}

添加spring约束并编写配置文件

有三种方式DI,推荐使用参数名注入

<?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="userDao" class="com.ls.ioc_03.UserDao"/>
<!--   按照参数的顺序DI -->
    <bean id="userService" class="com.ls.ioc_03.UserService">
        <constructor-arg value="20"/>
        <constructor-arg value="ls"/>
        <constructor-arg ref="userDao"/>
    </bean>

<!--    通过参数的名赋值-->
    <bean id="userService" class="com.ls.ioc_03.UserService">
        <constructor-arg name = "age" value="20"/>
        <constructor-arg name="name" value="ls"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>

<!--通过参数下标赋值  从0开始  从左开始-->
    <bean id="userService" class="com.ls.ioc_03.UserService">
        <constructor-arg index="0" value="20"/>
        <constructor-arg index="1" value="ls"/>
        <constructor-arg index="2" ref="userDao"/>
    </bean>
</beans>

2.2.2基于setter方法注入

开发中，除了构造函数注入（DI）更多的使用的Setter方法进行注入！

准备组件

public class UserDao {
}
public class UserService {
    private String name;

    private UserDao userDao;

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

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

添加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">

<!--    基于setter方法DI-->
<!--    确保组件类中有setter方法
            编写<property> 进行setter方法注入
                name  指的是set方法名字改为首字母小写
                          例如   setName   那么参数就是name
                value  基本类型
                ref    引用其他bean值为其他bean的id
-->


    <bean id="userDao" class="com.ls.ioc_04.UserDao"/>
    <bean id="userService" class="com.ls.ioc_04.UserService">
        <property name="name" value="ls"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

依赖注入包括基本类型注入和引用类型注入

2.3 IOC的创建以及使用

了解springIoc容器的接口和实现类

思路：

通过合适的实现类创建springIOC容器

准备组件

public class Dog {
    public  void   eat(){
        System.out.println("吃骨头~~");
    }
}

编写配置文件

   <bean id="dog" class="com.ls.ioc_05.Dog"/>

编写测试类，创建springioc容器并获取bean

    public static void main(String[] args) {
        //方式一：直接创建容器并指定配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("ioc_05.xml");

        //方式二： 先创建ioc容器，在指定配置文件，在刷新
//        ClassPathXmlApplicationContext context1 = new ClassPathXmlApplicationContext(); //创建ioc容器
//        context1.setConfigLocations("ioc_05.xml");   //配置ioc容器
//        context1.refresh();   //刷新ioc容器。
        
        Dog dog = context.getBean("dog", Dog.class);
        dog.eat();
    }
}

获得bean的三种方式

//方式1: 根据id获取
//没有指定类型,返回为Object,需要类型转化!
HappyComponent happyComponent = 
        (HappyComponent) iocContainer.getBean("bean的id标识");
        
//方式2: 根据类型获取
//根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理
//配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题
HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class);

//方式3: 根据id和类型获取 推荐
HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class);

2.4周期方法和作用域

周期方法： 在程序执行的过程中，到了某一时刻和条件，方法会自动执行。就是周期方法。

如servlet，用户向浏览器发出请求，tomcat接受请求，会创建对应的servlet，servlet的init，serviece，destory方法都可以看作是周期方法

在spring中，springioc容器的创建和销毁也可以看作是周期性的方法

准备组件

/**演示周期性方法
 *   方法  必须 是  public void 修饰 并且不能有参数
 */

public class JavaBean {
    public  void init(){
        //逻辑代码
        System.out.println("初始化");

    }
}

配置

<?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">

<!--    周期性方法-->
<!--    destroy-method ="方法名"
        init-method = "方法名"
                需要注意的是：方法必须有public void 修饰 并且不能有参数’
        -->

<!--    经过测验发现当ioc容器创建并实例化的时候，就执行了周期性方法 由此引入bean的作用域-->
<!--    bean的作用域
           <bean> 中scope 属性
                     singleton  在实例化ioc容器时就创建bean  默认
                     prototype  在获取bean对象的时候才会创建bean
 -->

    <bean id="javaBean" class="com.ls.ioc_06.JavaBean"  destroy-method="init" init-method="init"/>
</beans>

作用域：

bean的作用域

中scope 属性

singleton  在实例化ioc容器时就创建bean  默认

prototype  在获取bean对象的时候才会创建bean

  1. 作用域可选值
取值含义创建对象的时机默认值
singleton在 IOC 容器中，这个 bean 的对象始终为单实例IOC 容器初始化时是
prototype这个 bean 在 IOC 容器中有多个实例获取 bean 时否
如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：
取值含义创建对象的时机默认值
request请求范围内有效的实例每次请求否
session会话范围内有效的实例每次会话否

2.5 FactoryBean的特性和使用

三 XML配置方式管理组件综合练习

3.1环境搭建

  1. 需求分析

搭建一个三层架构案例，模拟查询全部学生（学生表）信息，持久层使用JdbcTemplate和Druid技术，使用XML方式进行组件管理！

a. 数据库准备

create database studb;

use studb;

CREATE TABLE students (
  id INT PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  gender VARCHAR(10) NOT NULL,
  age INT,
  class VARCHAR(50)
);

INSERT INTO students (id, name, gender, age, class)
VALUES
  (1, '张三', '男', 20, '高中一班'),
  (2, '李四', '男', 19, '高中二班'),
  (3, '王五', '女', 18, '高中一班'),
  (4, '赵六', '女', 20, '高中三班'),
  (5, '刘七', '男', 19, '高中二班'),
  (6, '陈八', '女', 18, '高中一班'),
  (7, '杨九', '男', 20, '高中三班'),
  (8, '吴十', '男', 19, '高中二班');

b. 创建项目引入依赖

<dependencies>
      <!--spring context依赖-->
      <!--当你引入SpringContext依赖之后，表示将Spring的基础依赖引入了-->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>6.0.6</version>
      </dependency>

      <!-- 数据库驱动和连接池-->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.25</version>
      </dependency>

      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.2.8</version>
      </dependency>

      <!-- spring-jdbc -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>6.0.6</version>
      </dependency>

</dependencies>

c. 实体类准备

public class Student {

    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String classes;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getClasses() {
        return classes;
    }

    public void setClasses(String classes) {
        this.classes = classes;
    }

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

d.jdbcTemplate技术

为了在特定领域帮助我们简化代码，Spring 封装了很多 『Template』形式的模板类。例如：RedisTemplate、RestTemplate 等等，包括 JdbcTemplate。

jdbcTemplate使用：

  1. 创建连接池对象 —>引入Druid

Druid的实例化用Druid依赖提供的实现类实例化，需要填四个必要的参数

  //0 创建一个连接池对象
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/studb");
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setName("root");
        druidDataSource.setPassword("root");

  1. 实例化JdbcTemplate对象

    1. 引入spring-jdbc依赖，根据该依赖提供的实现类实例化

    2. 导入数据源

    3. 调用方法

 public  void testForJava(){
        //0 创建一个连接池对象
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/studb");
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setName("root");
        druidDataSource.setPassword("root");


        //1. 实例化对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        //2.但是只有查询，并没有指定数据库，要先指定数据库才能对数据库操作
        //jdbcTemplate.setDataSource("数据源");
        jdbcTemplate.setDataSource(druidDataSource);

        //3.调用方法
        //jdbcTemplate.update() DDL DML DCL
        //jdbcTemplate.query();DQL 查询集合
        //jdbcTemplate.queryForObject(); 查询单个对象
    }
}

e. jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/studb
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=root

f.spring配置文件的编写.

**外部文件引入和使用**：

	因为配置数据源射击隐私问题，通常都是写到.properties中
    在配置数据源的时候引用文件内的数据所以要引入外部文件 value = ${key}
    使用context:property-placeholder 引入  这个标签需要引入约束：
              xmlns:context="http://www.springframework.org/schema/context"
    location="类地址"

<?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">


<!--    因为配置数据源射击隐私问题，通常都是写到.properties中
        在配置数据源的时候引用文件内的数据所以要引入外部文件 value = #{key}
        使用context:property-placeholder 引入  这个标签需要引入约束：
                  xmlns:context="http://www.springframework.org/schema/context"
        location="类地址"
-->

    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--       jdbcTemplate 配置-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--        setter方法注入  装配数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--    druidDataSource  配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!--        setter方法注入-->
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

3.2 JdbcTemplate的使用

import com.alibaba.druid.pool.DruidDataSource;
import com.ls.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/** jdbcTemplate的使用
 *     作用时简化数据库的CRUD 但是不提供连接池
 *     连接池引入 DruidDataSource 负责连接的创建和数据库驱动的注册
 *   1.实例化对象
 *   2.调用方法
 */
public class JdbcTemplateTest {

    @Test
    public  void testForJava(){
        //在springioc容器中已经将数据源注入了jdbcTemplate，减少了代码的耦合度
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean(JdbcTemplate.class);
        //jdbcTemplate.update()方法  插入 删除  修改
        //插入一条语句
        String sql = "insert into students (id,name,gender,age,class) values(?,?,?,?,?)";
        /** 参数1： sql语句 参数可以用？ 占位符
         *  参数2： Object ....param  可变参数，依次传入值
         *  return: 改变的行数
         */
        int rows = jdbcTemplate.update(sql, 499, "ls", "男", "20", "软工二班");
        System.out.println("更改了" + rows +"行");

        //查询单条数据 jdbcTemplate.queryForObject() ，并返回对应的数据对象,映射
        sql ="select *from students where id = ?";
        /** 参数1： sql
         * 参数2： RowMapper<T>  列名和属性名的映射器接口
         *          要实现接口的方法映射 手动创建所映射的对象，然后从结果集获取值对应赋值给对象，然后返回对象
         * 参数3：object .....param
         * return :  映射的类型
         */
        Student student = jdbcTemplate.queryForObject(sql, new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
                //rs 是sql的结果集  rownum 行数 不在意即可
                //手动将结果集映射到实体对象上
                Student student = new Student();
                student.setId(rs.getInt("id"));
                student.setAge(rs.getInt("age"));
                student.setName(rs.getString("name"));
                student.setGender(rs.getString("gender"));
                student.setClasses(rs.getString("class"));

                return student;
            }
        }, new Object[]{1});
        System.out.println(student);

        //查询多条语句 jdbcTemplate.query()
        sql = "select id,name,gender,age,class as classes from students";

        /** 参数一： sql
         *  参数二：RowMapper<T>  列名和属性名的映射器接口，
         *             接口可以自己实现如上所示，也可以用其实现类BeanPropertyRowMapper<T>(xxx.class)
         *                  自动将结果集映射，但是前提是列明和属性名一致，如果有不一致的可以as起别名
         *                  BeanPropertyRowMapper<T>(xxx.class) 会自动映射列和属性值
         * return ： list<T>
         */
        List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class));
        System.out.println(studentList);

    }
}

3.3编写实战

基于上述搭建，写一个查询所有学生信息的业务。

三层架构结构图

持久层：

/**
 * 操作学生类数据库的接口
 */
public interface StudentDao {

    /**
     * 查询所有学生数据
     * @return  学生集合
     */
    List<Student> findAllStudents();
}

//实现类
public class StudentDaoImp implements StudentDao {

    //使用jdbcTemplate
    private JdbcTemplate jdbcTemplate;
    //要使用setter注入 将jdbcTemplate 注入到 Dao层中
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 查找所有的学生信息
     * @return
     */
    @Override
    public List<Student> findAllStudents() {
        String sql = "select id,name,age,gender,class as classes from students";
        List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class));

        System.out.println(studentList);
        return studentList;
    }
}

业务层：

//service 层接口
public interface StudentService {

    /**
     * 查询所有学生信息 ---业务
     * @return
     */
    List<Student> findAllStudent();
}

//实现类
public class StudentServiceImp implements StudentService {
    //需要调用Dao层服务
    private StudentDao studentDao;
    //通过setter注入
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    /**
     * 查询所有学生信息 业务的实现
     * @return
     */
    @Override
    public List<Student> findAllStudent() {
        List<Student> allStudents = studentDao.findAllStudents();
        System.out.println("Service层----"+allStudents);
        return allStudents;
    }
}

表述层：

//控制层： 接受用户请求，处理请求参数 --->调用服务层，处理业务逻辑 --->将响应结果返回给用户（页面跳转）
public class StudentController {
    //调用服务层，处理业务逻辑
    private StudentService studentService;

    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    public  void findAll(){
        List<Student> studentList = studentService.findAllStudent();
        System.out.println("controller---------"+studentList);
    }
}

springioc的依赖注入

<?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">


<!--    因为配置数据源射击隐私问题，通常都是写到.properties中
        在配置数据源的时候引用文件内的数据所以要引入外部文件 value = #{key}
        使用context:property-placeholder 引入  这个标签需要引入约束：
                  xmlns:context="http://www.springframework.org/schema/context"
        location="类地址"
-->

    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--       jdbcTemplate 配置-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--        setter方法注入  装配数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--    druidDataSource  配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!--        setter方法注入  装配数据源-->
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

<!--   Dao层组件   实现类-->
    <bean id="studentDao" class="com.ls.Dao.imp.StudentDaoImp">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
<!--    Service 层组件-->
    <bean id="studentServiceImp" class="com.ls.service.imp.StudentServiceImp">
        <!--        注入 Dao的实现类-->
        <property name="studentDao" ref="studentDao"/>
    </bean>
    <!--        Controller 层组件-->
    <bean id="studentController" class="com.ls.controller.StudentController">
        <property name="studentService" ref="studentServiceImp"/>

    </bean>
</beans>

测试代码

public class MvcPractice {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("application.xml");

        //发送请求，controller接受请求
        StudentController controller = applicationContext.getBean(StudentController.class);
        controller.findAll();
    }
}

XMLIoC方式问题总结

优点：创建对象交给springioc容器管理确实减少了代码耦合度。

缺点：

  1. 注入的属性必须添加setter方法、代码结构乱！
  2. 配置文件和Java代码分离、编写不是很方便！
  3. XML配置文件解析效率低
hnsqls
关注
  • 49
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot中resource目录介绍与Thymeleaf使用
Xwz的博客
07-25 361
访问性static中的资源可以直接被 Web 浏览器请求和获取，而templates目录中的文件则需要经过服务器处理（如填充数据、执行逻辑）才能形成最终的页面。交互性templates目录下的文件通常包含动态内容，需要填充数据，适用于用户界面的动态交互，而static更多用于提供不会频繁变动的客户端代码和资源。技术实现static目录的处理较为简单，主要涉及静态文件的服务；templates的处理则复杂，涉及到模板引擎的选择和配置，以及与后端数据的动态绑定。
探索 Spring WebFlux：构建响应式 Web 应用
修复bug生成bug
07-25 354
Spring WebFlux 是 Spring 5 中引入的一个响应式 Web 框架，它是对 Spring MVC 的补充。与传统的 Spring MVC 不同，Spring WebFlux 基于 Reactor 项目，使用非阻塞的 I/O 和响应式流来处理请求和响应。
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
Takumilove的博客
07-24 1203
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
Spring踩坑：抽象类作为父类，使用子类@Autowired属性进行填充，属性值为null
five-five
07-25 1186
本文将深入探讨在Spring Boot 2.0及以上版本中使用抽象类作为父类时的最佳实践，特别关注依赖注入的正确使用方式。在Spring Boot 2.0及以上版本中，我们可以直接在抽象类的属性上使用@Autowired注解进行依赖注入。这意味着在构造器执行时，@Autowired注解的属性还没有被注入，它们的值为null。这个问题在子类中更加复杂。当你创建一个抽象类的子类时，子类的构造器会首先调用父类的构造器。这意味着即使是在子类的构造器中，父类中@Autowired注解的属性仍然是null。
SpringBoot添加密码安全配置以及Jwt配置
qq_64468032的博客
07-25 910
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
springboot3-web-questions-分析
weixin_62015493的博客
07-24 948
告警提示：解决：这个警告消息来自 Maven 编译器插件，提示参数已被弃用，并且不再由底层编译器评估。相反，Javac 二进制文件的实际版本会自动检索。参数已被弃用，这意味着即使你在 Maven 配置中指定了这个参数，它也不会影响编译器的行为。Maven 编译器插件会自动确定并使用已安装的 Java 编译器版本。解决方法一:如果你在pom.xml文件中指定了参数，可以安全地移除它。相反，应该确保你正确配置了source和target参数来指定编译的 Java 版本。
雪花算法 集群uid重复问题 uid-generator-spring-boot-starter
jiejiegua的博客
07-24 321
2、该业务是分部署集群部署以及使用的多线程获取uid，使用中发现唯一建冲突，生成的uid有重复。workerId 始终为0 怀疑是生成workerId出了问题。1、在生成环境 在某个业务使用该插件生成uid,由于业务整合了。发现 是保存响应的代码有问题，没有响应id。WorkerNodeEntity 类。addWorkerNode方法。WorkerNodeDAO 类。mybatis-plus模块。keyProperty参数。@Options注解加上。最后给获取方法 加上锁。给id加上 自增注解。
sed利用脚本处理文件
2201_75549363的博客
07-25 1029
sed 命令是利用脚本来处理文本文件。它可以依照脚本的指令来处理、编辑文本文件。主要用来自动编 辑一个或多个文件、简化对文件的反复操作、编写转换程序等。
【Springboot starter 组件开发】限流组件 RateLimiter
mst的专栏
07-25 301
基于guava的RateLimiter，实现限流； 基于redis + lua脚本(推荐，准确性高)，实现限流； 掌握springboot starter的开发流程。
springboot在加了mapper之后报错
最新发布
m0_74608954的博客
07-26 249
最后发现是spring boot版本不兼容，换成3.0.5之后可以了。springboot在加了mapper之后报错。
Spring AI (五) Message 消息
yuanchun的知识整理
07-24 1217
上下文 角色设置
SpringSecurity--DelegatingFilterProxy工作流程
weixin_46520767的博客
07-24 1364
DelegatingFilterProxy 是 Spring 提供的一个特殊的过滤器，它起到了桥梁的作用，可以让你在 Spring 容器中管理 Servlet 容器中的过滤器。
SpringBoot整合SSE技术详解
shyの个人笔记
07-23 900
本文详细介绍了如何在SpringBoot中整合Server-Sent Events (SSE)技术。文章阐述了SSE的基本概念、特点及其在SpringBoot中的实现方法,包括代码示例。同时,对比了SSE和WebSocket的区别,探讨了它们各自的优势和适用场景。文章强调SSE在单向实时通信中的简单性和效率,为开发者在选择实时通信技术时提供了valuable指导。
免费【2024】springboot 毕业生学历证明系统
weixin_53646065的博客
07-25 808
课题主要分为二大模块：即管理员模块和学生模块，主要功能包括：个人信息修改、学生、班级、部门、职位、学习形式、学制、专业、学历性质、转接地类型、学分、学历信息、签约单位等；
springSecurity学习之springSecurity过滤器
Lxn2zh的博客
07-25 363
匿名身份过滤器，这个过滤器个人认为很重要，需要将它与UsernamePasswordAuthenticationFilter 放在一起比较理解，spring security为了兼容未登录的访问，也走了一套认证流程，只不过是一个匿名的身份。表单提交了username和password，被封装成token进行一系列的认证，便是主要通过这个过滤器完成的，在表单认证的方法中，这是最最关键的过滤器。这个过滤器决定了访问特定路径应该具备的权限，访问的用户的角色，权限是什么？访问的路径需要什么样的角色和权限？
SpringCloud之feign
qq_15740137的博客
07-25 872
SpringCloud之Feign的使用
免费【2024】springboot 毕业设计管理系统
weixin_53646065的博客
07-24 813
本文讲述了毕业设计管理系统。结合电子管理系统的特点，分析了毕业设计管理系统的背景，给出了毕业设计管理系统实现的设计方案。
使用Springboot + netty 打造聊天服务（一）
Java 技术专栏，从入门到精通，熟悉企业级开发
07-22 2540
/ 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);
SpringBoot读取配置的6种方式
一起coding，一起嗨。
07-25 767
SpringBoot读取配置的6种方式
Spring IoC容器详解：从基础到深入
第三章聚焦于Spring的IoCServiceProvider，它是Spring IoC容器的核心组件，负责管理和配置对象之间的依赖关系。讲解了三种常见的依赖关系管理方式：直接编码、配置文件和元数据驱动，帮助读者理解如何通过这些机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值