Spring1(初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题)

26 阅读 0 评论 0 点赞

创建项目

集成maven

创建一个Maven项目

实现：

在pom配置依赖：

初识Spring

Spring简介

Spring是分层的轻量级开源框架，以IoC[反转控制]和AoP[面向切面编程]为内核，提供了展现层SpringMVC和持久层SpringJDBC以及业务层的事务管理。

Spring 是分层的 Java SE/EE 应⽤ full-stack 轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切⾯编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，逐渐成为使⽤最多的 Java EE 企业应⽤开源框架。

官方网站：https://spring.io/

Spring的发展历史

企业级应用指的是大规模、性能和安全要求高、业务复杂、灵活多变的大型 WEB 应用程序。

大规模：用户量和 IP/PV访问量大、海量数据、功能模块多代码量大。
业务复杂：涉及金融、期货、电信等特殊领域的业务逻辑复杂，对系统架构提出新要求。
性能和安全要求高：响应毫秒数和安全级别均有很高的要求。
灵活多变：经常性的业务变更，也对开发效率以及项目部署等工作有更高的要求。

重量级技术向轻量级开发过度

为了实现企业级应用开发各类需求，涌现出以EJB为代表的一系列技术。

Spring之父

Rod Johnson，SpringFramework创始人, interface21 CEO。

• 1996 年开始关注 Java 服务器端技术

• Servlet2.4 和 JDO2.0 专家组成员

• Expert One-to-One J2EE Design and Development(2002)

• 阐述了 J2EE 使用EJB 开发设计的优点及解决方案

• Expert One-to-One J2EE Development without EJB(2004)

• 阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形）

• 2004年3月24日发布了Spring Framework 1.0 final

技术主张：技术应当回归实用为主，简化 Java 开发

Spring的理论基础：Spring 框架建立在本书中对于J2EE企业级应用的开发与设计的核心理念之上，追求简洁、轻量级的开发方式，让系统具备更好的健壮性和可扩展性。

体系结构

Spring Core：Spring框架的最基础部分，提供DI（依赖注入）特性。
Spring Context：Spring上下文，提供Bean容器的集合。
Spring AOP：基于Spring Core的符合规范的切面编程的实现。
Spring JDBC：提供了JDBC的抽象层，简化了JDBC编码。
Spring ORM：对主流ORM框架（Hibernate、Toplink等）进行集成。
Spring Web：为Spring在Web应用程序中的使用提供了支持。

生态系统

Spring Boot：简化产品级的 Spring 应用和服务的创建，简化了配置文件，使用嵌入式web服务器，含有诸多开箱即用微服务功能。
Spring Data：是一个数据访问及操作的工具包，封装了很多种数据及数据库的访问相关技术，包括：jdbc、Redis、MongoDB、Neo4j等。
Spring AMQP：消息队列操作的工具包，主要是封装了RabbitMQ的操作。
Spring Cloud：微服务工具包，用于创建基于云计算架构的原生微服务应用。
Spring Security：是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。
Spring Mobile：是Spring MVC的扩展，用来简化手机上的Web应用开发。

Spring【Spring FrameWork】解决的问题：

官方文档

Spring文档：https://docs.spring.io/spring-framework/docs/5.2.25.RELEASE/spring-framework-reference/core.html#spring-core

解耦实现

Spring的两大核心思想：IOC和AOP

SpringIOC(控制反转)SpringDI(依赖注入)
SpringAOP(面向切面思想)

SpringIOC：SpringIOC容器扮演项目的载体，IOC容器是可以使项目更符合高内聚，低耦合的思想“解耦”

耦合：类与类之间有耦合，方法与方法有耦合

解耦：

尽量避免new对象，通过反射实例化
需要创建的对象不要写死，而是把类名保存在独立的Properties文件中按需加载

JDBC

package com.stringzhua;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * @Author Stringzhua
 * @Date 2024/9/9 19:30
 * description:
 */
class Test01 {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/lmonkeyshop?serverTimezone=GMT", "root", "12345678");
            System.out.println(root);
        } catch (ClassNotFoundException exception) {
            exception.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

SpringBoot整合MyBatis和lombok，开启驼峰映射

=================mybaits自动驼峰映射====================
JavaBean                DB
stuId                   stu_id
stuName                 stu_name
<!--自动驼峰映射-->
<settings>
  <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>


=================junit====================
含义：方法级别的单元测试工具
步骤：
    1.坐标
    2.注解
        @Test=============main
        @Before===========main执行之前
        @After============main执行之后


=================lombok====================
步骤：
    1.idea安装插件（只安装一次）
    2.坐标
    3.注解

项目结构如下：
在这里插入图片描述

Dao层：

StudentMapper.java

package com.stringzhua.dao;

import com.stringzhua.pojo.Student;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @Author Stringzhua
 * @Date 2024/9/9 16:08
 * description:mybatis 的 mapper
 */
public interface StudentMapper {

    @Select("select * from student")
    public List<Student> findAll();

    @Insert("insert into student(stu_name,nick_name,stu_age) values (#{stuName},#{nickName},#{stuAge})")
    public void add(Student s);
}

mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--自动驼峰映射-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <!--开发模式-->
    <environments default="env">
        <environment id="env">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mavendb?serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="12345678"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射器注册-->
    <mappers>
        <package name="com.stringzhua.dao"/>
    </mappers>

</configuration>

POJO层：

Stundet.java

package com.stringzhua.pojo;

import lombok.*;

import java.io.Serializable;

/**
 * @Author Stringzhua
 * @Date 2024/9/9 16:03
 * description:
 */


/**
 * @AllArgsConstructor 满参构造
 * @NoArgsConstructor 无参构造
 * @ToString toString方法
 * @Getter getter方法
 * @Setter setter方法
 * @Data 提供类的get、set、equals、hashCode、canEqual、toString方法
 *
 * canEqual
 * 除非您的类 isfinal和 extends java.lang.Object，
 * 否则 lombok 会生成一个canEqual方法，这意味着 JPA 代理
 * 仍然可以等于它们的基类，但是添加新状态的子类不会破坏 equals 契约。
 */

@NoArgsConstructor
@Data
public class Student implements Serializable {
    private int stuId;
    private String stuName;
    private String nickName;
    private int stuAge;

    public Student(String stuName, String nickName, int stuAge) {
        this.stuName = stuName;
        this.nickName = nickName;
        this.stuAge = stuAge;
    }
}

单元测试：

package com.stringzhua.test;

import com.stringzhua.pojo.Student;
import com.stringzhua.dao.StudentMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @Author Stringzhua
 * @Date 2024/9/9 16:14
 * description:
 * @Before 指的是@Test注解运行之前要执行的方法
 * @Test 指的是要执行测试的方法
 * @After 指的是@Test注解运行之后执行的方法
 */
public class Test01 {
    SqlSession sqlSession = null;
    StudentMapper studentmapper = null;

    @Before
    public void beforeMethod() {
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = sqlSessionFactoryBuilder.build(inputStream);
            sqlSession = factory.openSession(true);
            studentmapper = sqlSession.getMapper(StudentMapper.class);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @After
    public void afterMethod() {
        sqlSession.close();
    }


    @Test
    public void show1() throws Exception {


        studentmapper.add(new Student("猫猫", "千逐", 18));
        studentmapper.add(new Student("田欣怡", "晞苒", 22));
    }

    @Test
    public void show2() throws Exception {
        List<Student> all = studentmapper.findAll();
        for (int i = 0; i < all.size(); i++) {
            Student student = all.get(i);
            System.out.println(student);
        }
    }
}

三层思想

项目结构如下：

首先需要在main—>resources下新建一个properties配置文件

service=com.stringzhua.service.UserServiceImpl
dao=com.stringzhua.dao.UserDaoImpl

Controller层：

IUserController.java

package com.stringzhua.controller;

public interface IUserController {
    public void save();
}

UserControllerImpl.java

package com.stringzhua.controller;


import com.stringzhua.service.IUserService;
import com.stringzhua.util.BeansFactory;

public class UserControllerImpl implements IUserController {

    //耦合度高
//    IUserService service = new UserServiceImp();

    //耦合度低,通过工厂创建service对象
    IUserService service = (IUserService) BeansFactory.getBean("service");

    public void save() {
        System.out.println("===controller的新增===");
        service.save();
    }
}

Dao层：

IUserDao.java

package com.stringzhua.dao;

public interface IUserDao {
    public void save();
}

UserDaoImpl.java

package com.stringzhua.dao;

public class UserDaoImpl implements IUserDao{

    public void save() {
        System.out.println("===dao的新增===");
    }
}

Service层：

IUserService.java

package com.stringzhua.service;

public interface IUserService {
    public void save();
}

UserServiceImpl.java

package com.stringzhua.service;


import com.stringzhua.dao.IUserDao;
import com.stringzhua.util.BeansFactory;

public class UserServiceImpl implements IUserService{


    //耦合度高
//    IUserDao dao = new UserDaoImp();

    //耦合度低,通过工厂去创建dao对象
    IUserDao dao = (IUserDao) BeansFactory.getBean("dao");


    public void save() {
        System.out.println("===serivce的新增===");
        dao.save();
    }
}

Utils工具类：

BeansFactory.java

package com.stringzhua.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeansFactory {

    static Properties properties;

    static {
        try {
            //1.工具类
            properties = new Properties();
            //2.加载文件
            InputStream resourceAsStream = BeansFactory.class.getClassLoader().getResourceAsStream("beans.properties");
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static Object getBean(String key) {
        Object object = null;
        try {
            //1.获取key对应的value
            String classPath = properties.getProperty(key);
            //2.创建对象,反射,newInstance()去创建对象
            object = Class.forName(classPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException exception) {
            exception.printStackTrace();
        }
        return object;
    }
}

测试：

package com.stringzhua.test;


import com.stringzhua.controller.IUserController;
import com.stringzhua.controller.UserControllerImpl;

public class Test01 {
    public static void main(String[] args) {
        IUserController controller = new UserControllerImpl();
        controller.save();
    }
}

SpringIOC

Spring环境搭建：

坐标---->配置文件

SpringIOC：控制反转

关键字：IOC名词解释，作用是解耦，使用IOC容器管理项目组件之间的耦合关系

IOC(Inversion Of Control 中文释义：控制反转)是Spring框架的核心思想之一，主要用于解耦。IOC是将创建的对象的控制权交给Spring框架进行管理。由Spring框架根据配置文件或注解等方式，创建Bean对象并管理各个Bean对象之间的依赖关系，使对象之间形成松散耦合的关系，实现解耦。

控制：指的是对象创建(实例化、管理)的权力

反转：控制权交给外部环境(Spring框架、IOC容器)

SpringIOC使用步骤：

创建类
将需要Spring管理的类，注入SpringIOC容器

<bean id="唯一标识" class="类的完全限定名称"></bean>

以解耦的方式获取JavaBean实例对象
1. 加载Spring主配置文件，获取Spring核心对象

            ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");

2. 获取JavaBean

Student  student = (Student) applicationContext.getBean("student");

实现

在pom.xml中配置：

<dependencies>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.25</version>
  </dependency>
</dependencies>

项目结构如下图所示：

Controller层：

IUserController.java

package com.stringzhua.controller;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:28
 * description:
 */
public interface IUserController {
    public void add();
}

UserControllerImpl.java

package com.stringzhua.controller;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:29
 * description:
 */
public class UserControllerImpl implements  IUserController{
    public void add() {
        System.out.println("=====controller层的save()====");
    }
}

Dao层：

IUserDao.java

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:37
 * description:
 */
public interface IUserDao {
    public void add();
}

UserDaoImpl.java

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:37
 * description:
 */
public class UserDaoImpl implements IUserDao{
    public void add() {
        System.out.println("=====dao层的add()====");
    }
}

POJO层：

Student.java

package com.stringzhua.pojo;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:21
 * description:
 */
public class Student {

}

Service层：

IUserService.java

package com.stringzhua.service;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:38
 * description:
 */
public interface IUserService {
    public void add();
}

UserServiceImpl.java

package com.stringzhua.service;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:38
 * description:
 */
public class UserServiceImpl implements IUserService{
    public void add() {
        System.out.println("=====service层的add()====");
    }
}

测试类：

package com.stringzhua.test;

import com.stringzhua.controller.IUserController;
import com.stringzhua.dao.IUserDao;
import com.stringzhua.pojo.Student;
import com.stringzhua.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Date;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 14:22
 * description:
 */
public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件获取ioc容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.获取javaBean
        //默认为Object类型的对象,需要转换类型
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student);

        IUserController controller = (IUserController) applicationContext.getBean("controller");
        controller.add();
        IUserService service = (IUserService) applicationContext.getBean("service");
        service.add();
        IUserDao dao = (IUserDao) applicationContext.getBean("dao");
        dao.add();

        Date date = (Date) applicationContext.getBean("date");
        System.out.println(date);
    }
}

两个Demo的对比：

SpringDI

SpringDI：依赖注入

DI（Dependency Inject，中文释义：依赖注入）

是对IOC概念的不同角度的描述，是指应用程序在运行时，每一个Bean对象都要依赖IOC容器注入当前Bean对象所需要的另外一个Bean对象。

例如：在MyBatis整合Spring时，SqlSessionFactoryBean依赖IOC注入一个DataSource数据源Bean

SpringDI的实现方式：

set注入
构造注入
注解注入

SpringDI支持的数据类型：

基本数据类型与String类型
JavaBean对象
复杂类型（构造注入不支持）

DI实现步骤：

思考
提供对应方法(set) set(XXXXX)
配置

<property 属性名="属性值"></property>
        属性：
           name：属性名
           ref：注入的值的引用
           value：注入的值

DI实现步骤 (构造实现)：

思考
提供对应的构造方法（构造）
配置

 <constructor-arg 属性名="属性值"></constructor-arg>
         属性：
           name：属性名
           type: 参数类型
           index: 参数下标
           ref：注入的值的引用
           value：注入的值

总结IOC和DI

原来要对象，自己造自己用

现在要对象，容器造，容器拼一块，自己用

“Spring胶水框架”

set注入

在pom.xml中进行配置：

 <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.25</version>
</dependency>

项目结构：

全部代码：

Controller层：

IUserController.java

package com.stringzhua.controller;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 16:02
 * description:
 */
public interface IUserController {
    public void add();
}

UserControllerImpl.java

package com.stringzhua.controller;

import com.stringzhua.service.IUserService;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 16:03
 * description:
 */
public class UserControllerImpl implements IUserController {

    IUserService service;
    //di注入步骤1:提供set方法
    public void setService(IUserService service) {
        this.service = service;
    }

    public void add() {
        System.out.println("==controller层的add方法==");
        service.add();
    }
}

Dao层：

IUserDao.java

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 15:59
 * description:
 */
public interface IUserDao {
    public void add();
}

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 16:00
 * description:
 */
public class UserDaoImpl implements IUserDao{
    public void add() {
        System.out.println("=====Dao层的add方法===");
    }
}

POJO层：

Student.java

package com.stringzhua.pojo;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 15:54
 * description:
 */
public class Student {
    private String stuName;
    private int stuAge;
    //di步骤1:提供set方法

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }
}

Teacher.java

package com.stringzhua.pojo;

import java.util.*;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:06
 * description:
 */
public class Teacher {
    private List mylist;
    private Set myset;
    private String[] myarray;
    private Map mymap;
    private Properties prop;

    public void setMylist(List mylist) {
        this.mylist = mylist;
    }

    public void setMyset(Set myset) {
        this.myset = myset;
    }

    public void setMyarray(String[] myarray) {
        this.myarray = myarray;
    }

    public void setMymap(Map mymap) {
        this.mymap = mymap;
    }

    public void setProp(Properties prop) {
        this.prop = prop;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "mylist=" + mylist +
                ", myset=" + myset +
                ", myarray=" + Arrays.toString(myarray) +
                ", mymap=" + mymap +
                ", prop=" + prop +
                '}';
    }
}

Service层：

IUserService.java

package com.stringzhua.service;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 16:01
 * description:
 */
public interface IUserService {
    public void add();
}

UserServiceImpl.java

package com.stringzhua.service;

import com.stringzhua.dao.IUserDao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 16:01
 * description:
 */
public class UserServiceImpl implements IUserService {
    IUserDao dao;

    public void setDao(IUserDao dao) {
        this.dao = dao;
    }

    public void add() {
        System.out.println("==Service层的add方法==");
        dao.add();
    }
}

测试类：

Test.java

package com.stringzhua.test;

import com.stringzhua.controller.IUserController;
import com.stringzhua.pojo.Student;
import com.stringzhua.pojo.Teacher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 15:57
 * description:
 */
public class Test01 {
    public static void main(String[] args) {
        //1.获取Application对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.获取JavaBean
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student);

        IUserController controller = (IUserController) applicationContext.getBean("controllerImpl");
        controller.add();

        Teacher teacher = (Teacher) applicationContext.getBean("teacher");
        System.out.println(teacher);
    }
}

实现：set注入基本数据类型与String

applicationContext.xml

 <!--    set注入基本数据类型与String-->
    <bean id="student" class="com.stringzhua.pojo.Student">
        <property name="stuName" value="晞冉"></property>
        <property name="stuAge" value="20"></property>
    </bean>

//1.获取Application对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.获取JavaBean
Student student = (Student) applicationContext.getBean("student");
System.out.println(student);

实现：set注入javabean对象

applicationContext.xml

 <!--    set注入JavaBean-->
<bean id="daoImpl" class="com.stringzhua.dao.UserDaoImpl"></bean>

<bean id="serviceImpl" class="com.stringzhua.service.UserServiceImpl">
    <property name="dao" ref="daoImpl"></property>
</bean>

<bean id="controllerImpl" class="com.stringzhua.controller.UserControllerImpl">
    <property name="service" ref="serviceImpl"></property>
</bean>

//1.获取Application对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.获取JavaBean
IUserController controller = (IUserController) applicationContext.getBean("controllerImpl");
controller.add();

实现：set注入复杂类型

applicationContext.xml

<!--    set注入复杂类型-->
<bean id="teacher" class="com.stringzhua.pojo.Teacher">
<property name="mylist">
    <list>
        <value>有何不可</value>
        <value>断桥残雪</value>
        <value>千百度</value>
        <value>老古董</value>
        <value>三尺</value>
    </list>
</property>

<property name="myset">
    <set>
        <value>田晞冉</value>
        <value>李芸芸</value>
        <value>董万鹏</value>
        <value>高夏斌</value>
    </set>
</property>

<property name="myarray">
    <array>
        <value>雁塔区</value>
        <value>莲湖区</value>
        <value>长安区</value>
        <value>长安区</value>
        <value>高新区</value>
    </array>
</property>

<property name="mymap">
    <map>
        <entry key="袁继峰" value="男"></entry>
        <entry key="陈博文" value="男"></entry>
        <entry key="郭忠航" value="男"></entry>
    </map>
</property>

<property name="prop">
    <props>
        <prop key="王文茜">已毕业</prop>
        <prop key="赵文瑜">未毕业,大四</prop>
        <prop key="张玉婷">文科专业转码</prop>
    </props>
</property>

//1.获取Application对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.获取JavaBean
Teacher teacher = (Teacher) applicationContext.getBean("teacher");
System.out.println(teacher);

构造注入：

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.25</version>
        </dependency>
    </dependencies>

项目结构：

全部代码：

Controller层：

IUserController.java

package com.stringzhua.controller;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 18:00
 * description:
 */
public interface IUserController {
    public void add();
}

UserControllerImpl.java

package com.stringzhua.controller;

import com.stringzhua.service.IUserSerivce;
import com.stringzhua.service.UserServiceImpl;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 18:01
 * description:
 */
public class UserControllerImpl implements IUserController {
    IUserSerivce serivce;

    public UserControllerImpl() {
    }

    public UserControllerImpl(IUserSerivce serivce) {
        this.serivce = serivce;
    }

    public void add() {
        System.out.println("==UserController层的add方法==");
        serivce.add();
    }
}

Dao层：

IUser.java

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:57
 * description:
 */
public interface IUserDao {
    public void add();
}

UserDaoImpl.java

package com.stringzhua.dao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:58
 * description:
 */
public class UserDaoImpl implements IUserDao {

    public void add() {
        System.out.println("==UserDao层的add方法==");
    }
}

POJO层：

Student.java

package com.stringzhua.pojo;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:50
 * description:
 */
public class Student {
    private String stuName;
    private int stuAge;

    public Student() {
    }

    public Student(String stuName, int stuAge) {
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }
}

Service层；

IUserService.java

package com.stringzhua.service;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:59
 * description:
 */
public interface IUserSerivce {
    public void add();
}

UserServiceImpl.java

package com.stringzhua.service;

import com.stringzhua.dao.IUserDao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:59
 * description:
 */
public class UserServiceImpl implements IUserSerivce {
    IUserDao dao;

    public UserServiceImpl() {
    }

    public UserServiceImpl(IUserDao dao) {
        this.dao = dao;
    }

    public void add() {
        System.out.println("==UserSerivce层的add方法==");
        dao.add();
    }
}

Test：

test.java

package com.stringzhua.service;

import com.stringzhua.dao.IUserDao;

/**
 * @Author Stringzhua
 * @Date 2024/9/10 17:59
 * description:
 */
public class UserServiceImpl implements IUserSerivce {
    IUserDao dao;

    public UserServiceImpl() {
    }

    public UserServiceImpl(IUserDao dao) {
        this.dao = dao;
    }

    public void add() {
        System.out.println("==UserSerivce层的add方法==");
        dao.add();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--    构造注入基本类型与String-->
<!--    <bean id="student" class="com.stringzhua.pojo.Student">-->
<!--        <constructor-arg name="stuName" value="晞冉"></constructor-arg>-->
<!--        <constructor-arg name="stuAge" value="18"></constructor-arg>-->
<!--    </bean>-->
<!--    <bean id="student" class="com.stringzhua.pojo.Student">-->
<!--        <constructor-arg index="0" value="晞冉"></constructor-arg>-->
<!--        <constructor-arg index="1" value="18"></constructor-arg>-->
<!--    </bean>-->
    <bean id="student" class="com.stringzhua.pojo.Student">
        <constructor-arg type="java.lang.String" value="晞冉"></constructor-arg>
        <constructor-arg type="int" value="18"></constructor-arg>
    </bean>

    <!--    ==构造注入javabean==-->
    <bean id="daoImpl" class="com.stringzhua.dao.UserDaoImpl"></bean>

    <bean id="serviceImpl" class="com.stringzhua.service.UserServiceImpl">
        <constructor-arg name="dao" ref="daoImpl"></constructor-arg>
    </bean>

    <bean id="controllerImpl" class="com.stringzhua.controller.UserControllerImpl">
        <constructor-arg name="serivce" ref="serviceImpl"></constructor-arg>
    </bean>
</beans>

实现：构造注入基本类型与String类型

applicationContext.xml

<bean id="student" class="com.stringzhua.pojo.Student">
        <constructor-arg name="stuName" value="晞冉"></constructor-arg>
        <constructor-arg name="stuAge" value="18"></constructor-arg>
    </bean>
    <bean id="student" class="com.stringzhua.pojo.Student">
        <constructor-arg index="0" value="晞冉"></constructor-arg>
        <constructor-arg index="1" value="18"></constructor-arg>
    </bean>
    <bean id="student" class="com.stringzhua.pojo.Student">
        <constructor-arg type="java.lang.String" value="晞冉"></constructor-arg>
        <constructor-arg type="int" value="18"></constructor-arg>
    </bean>

Test.java

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) applicationContext.getBean("student");
System.out.println(student);

实现：构造注入javabean对象

applicationContext.xml

<!--    &lt;!&ndash;    ==构造注入javabean==&ndash;&gt;-->
<bean id="daoImpl" class="com.stringzhua.dao.UserDaoImpl"></bean>

<bean id="serviceImpl" class="com.stringzhua.service.UserServiceImpl">
  <constructor-arg name="dao" ref="daoImpl"></constructor-arg>
</bean>

<bean id="controllerImpl" class="com.stringzhua.controller.UserControllerImpl">
  <constructor-arg name="serivce" ref="serviceImpl"></constructor-arg>
</bean>

Test.java

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//        Student student = (Student) applicationContext.getBean("student");
//        System.out.println(student);

IUserController controller = (IUserController) applicationContext.getBean("controllerImpl");
controller.add();

Spring常见面试题

Spring 框架的基本理解

关键字: 核心思想IOC\AOP、作用（解耦、简化），简单描述框架组成
Spring 框架是一款轻量级的开发框架，核心思想是 IOC（控制反转）和 AOP（面向切面编程) 为java 应用程序开发提供组件管理服务，用于组件之间的解耦，以及简化第三方JavaEE中间件技术的使用（jms、任务调度、缓存、orm 框架），是一个基础架构型的开发框架
Spring框架包括： IOC容器、Validation 数据校验、AOP面向切面编程、Transactions 事务管理、SpringJDBC 、Spring MVC框架、以及各类第三方JavaEE 中间件技术集成

Spring 框架由哪些模块组成?

关键字: 官方文档描述，由7个模块组成
Spring framwork 根据官方文档的描述，主要包括以下常用5个模块:
1. Core:核心模块 包括: IoC Container（loc容器），Events（事件通知机制），Resources（资源加载机制），118n（国际化），Validation（数据校验），Data Binding（数据绑定），Type Conversion（类型转换），spEl（spring表达式），AOP（面向切面编程）;
2. Testing:测试模块 包括: Mock Objects（测试模拟对象），TestContext Framework（测试框架），Spring MVC Test（用于测试Spring MVC），WebTestClient（用于测试WebClient 、Restful、Webflux等）
3. Data Access:数据访问模块 包括:Transactions （事务管理），Dao Support （统一的 Data Access Object DAO 模式封装），jdbc（spring 对于 jdbc 的操作封装），O/R Mapping（ spring 对于对象关系映射框架的封装，例如 hibernate 等框架）等;
4. Web servlet:基于servlet的web应用开发 包括: Spring Mvc（ Spring 基于 Mvc 模式设计封装的Web 框架）， WebSocket（spring集成 websocket，websocket 是一个服务器与客户端双向通信的技术）等;
5. Integration:企业级系统集成模块（不同系统之间的交互集成) 包括∶ remoting（spring 用于在分布式系统中进行远程服务调用的通讯框架）

Spring IOC的理解

关键字: IOC 名词解释，作用是解耦，使用IOC容器管理项目组件之间的耦合关系
IOC（Inversion of control，中文释义:控制反转）是 Spring 框架的核心思想之一，主要用于解耦。IOC 是指将创建对象的控制权转移给 Spring 框架进行管理。由spring框架根据配置文件或注解等方式，创建Bean对象并管理各个 Bean 对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦。
- 控制：指的是对象创建（实例化、管理）的权力
- 反转：控制权交给外部环境（ Spring 框架、IoC 容器 )

Spring IOC容器的理解

关键字: IOC 容器的作用、存储形式、初始化过程
IOC 通常被理解为 IOC Container 容器，IOC 容器其实就是一个 Map，key 是每个bean对象的ID，value 是 bean 对象本身。IOC 容器负责创建 bean 对象并管理 bean 的生命周期。并且根据配置好配置文件或注解，管理 ioc 容器中的每个bean，以及根据bean之间的依赖关系，完成bean之间的注入
IOC 容器属于Spring core模块，用来创建和管理bean，默认使用单例的方式将bean存储在 DefaultListableBeanFactory类的beanDefinitionMap中（一个 ConcurrentHashMap 类型的Map集合）
IOC 容器使用 ConcurrentHashMap 集合存储了 BeanDefinition 对象，该对象封装了 Spring 对一个 Bean 所有配置信息，包括：类名，属性，构造方法参数，依赖，是否延迟加载，是否是单例等配置信息

Spring DI的理解

DI（ dependecy inject，中文释义:依赖注入）是对 IOC 概念的不同角度的描述，是指应用程序在运行时，每一个 bean 对象都依赖 IOC 容器注入当前 bean 对象所需要的另外一个 bean 对象。（例如在 mbatis整合 spring 时，SqlSessionFactoryBean 依赖 ioc 容器注入一个 DataSource 数据源 bean ）

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » Spring1(初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题)

点赞(0) 打赏

本文分类：文章资讯
本文标签：Spring1(初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题)
浏览次数：26 次浏览
本文链接：https://freeymw.com/article/35400.html

上一篇 > Web Broker（Web服务应用程序）入门教程（3）
下一篇 > Spring Boot 注解大全：全面解析 Spring Boot 常用注解及其应用场景

评论列表共有 0 条评论

暂无评论

Spring1(初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题)

Spring1

创建项目

集成maven

创建一个Maven项目

实现：

初识Spring

Spring简介

Spring的发展历史

Spring之父

体系结构

生态系统

官方文档

解耦实现

JDBC

SpringBoot整合MyBatis和lombok，开启驼峰映射

三层思想

SpringIOC

实现

SpringDI

set注入

全部代码：

实现：set注入基本数据类型与String

实现：set注入javabean对象

实现：set注入复杂类型

构造注入：

全部代码：

实现：构造注入基本类型与String类型

实现：构造注入javabean对象

Spring常见面试题

Spring 框架的基本理解

Spring 框架由哪些模块组成?

Spring IOC的理解

Spring IOC容器的理解

Spring DI的理解

评论列表 共有 0 条评论

发表评论 取消回复

评论列表共有 0 条评论

发表评论取消回复