Spring-IoC理解

新建一个Maven工程

在pom文件中导入需要的依赖

<?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.lps</groupId>
    <artifactId>Spring-002-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

<!--    依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.23</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>


</project>

我这里用jdk17

可以ctrl+shift+ait+s调出structure进行jdk的配置看个人使用情况配置

public class User {
    //默认情况下spring通过反射机制 调用类的无参构造方法来实例化对象
    //实现原理如下
    //Class hhh = Class.forName("com.lps.bean.User");
    //hhh.newInstance();
    public User() {
        System.out.println("User的无参构造方法执行");
    }

    //当我们定义了有参构造器 无参构造器就无法实例了 所以记得定义下无参
    //No default constructor found;
    // nested exception is java.lang.NoSuchMethodException: com.lps.bean.User.<init>()
    public User(User u) {
        System.out.println("User的无参构造方法执行");
    }

}

public class Vip {
    public Vip() {
        System.out.println("vip的无参构造器运行");
    }
}

public class UserDaoImplForMysql {
    public UserDaoImplForMysql() {

    }
    public void insert(){
        System.out.println("刘品水正在使用mysql保存信息");
    }
}

接下来是spring的xml配置

spring.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">

<!--    id是bean的身份证号 不能重复 是唯一的标识-->
    <bean id="userBean" class="com.lps.bean.User"></bean>
<!--    <bean id="userBean" class="com.lps.bean.Vip"></bean>-->
<!--    spring-->
    <bean id="UserDaoImplForMysql" class="com.lps.dao.UserDaoImplForMysql"></bean>


</beans>

bean.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">

<!--    id是bean的身份证号 不能重复 是唯一的标识-->
    <bean id="userBean" class="com.lps.bean.User"></bean>
<!--    <bean id="userBean" class="com.lps.bean.Vip"></bean>-->
<!--    spring-->
    <bean id="UserDaoImplForMysql" class="com.lps.dao.UserDaoImplForMysql"></bean>


</beans>

beans.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">

    <bean id="vip0" class="com.lps.bean.Vip"></bean>
    <bean id="userBean" class="com.lps.bean.User"></bean>
    <bean id="UserDaoImplForMysql0" class="com.lps.dao.UserDaoImplForMysql"></bean>

<!--    配置java.util.Data   Bean-->
    <bean id="nowTime" class="java.util.Date"></bean>

</beans>

最后写一个测试类来感受IoC的好处即可

package com.lps.test;

import com.lps.bean.User;
import com.lps.dao.UserDaoImplForMysql;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * ClassName: FirstSpringTest
 * Description:
 * Date: 2022/11/18 22:07
 * <author>          <time>          <version>          <desc>
 * 刘品水         2022/11/18 22:07     @Version 1.0      描述
 */
public class FirstSpringTest {
    @Test
    public void testBeginInitBean(){
        //执行以下代码就会执行实例化对象了 并不是getBean()方法调用的时候
        new ClassPathXmlApplicationContext("spring.xml");
    }

    @Test
    public void testBeanFactory(){
        //ApplicationContext接口的超级父类是BeanFactory(Bean工厂)
        //BeanFactory是IoC容器的顶级接口
        //Spring的IoC容器底层使用了;工厂模式
        //Spring底层的IoC是通过：XML解析、工厂模式、反射机制
        BeanFactory context = new ClassPathXmlApplicationContext("spring.xml");
        User bean = context.getBean("userBean", User.class);
        System.out.println(bean);
    }



    @Test
    public void testXmlPath(){
        FileSystemXmlApplicationContext context
                //= new FileSystemXmlApplicationContext("G:/JavaProject/Spring/beans.xml");
                = new FileSystemXmlApplicationContext("G:\\JavaProject\\Spring\\beans.xml");
        //用途不同
        //1、“＼”：“＼”只能用来表示目录。
        //2、“／”：“／”技能作为除法符号或者间隔符号使用，也能用来表示目录。

        Date nowTime = context.getBean("nowTime", Date.class);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:ss:SSS");
        String nowtime = format.format(nowTime);
        System.out.println(nowtime);

    }


    @Test
    public void testFirstSpringCode(){
        //ApplicationContext应用上下文 spring容器 是一个接口 有很多实现类 其中有一个叫ClassPathXmlApplicationContext
        //ClassPathXmlApplicationContext：专门从类路径加载spring配置文件的spirng上下文对象
        /*ApplicationContext applicationContext=
                new ClassPathXmlApplicationContext("spring.xml","bean.xml");*/
        ApplicationContext applicationContext=
                new ClassPathXmlApplicationContext("spring.xml","bean.xml","xml/beans.xml");
        //这段代码只要执行 相当于启动了spring容器 解析spring.xml文件 实例化所有的spring文件
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);

        Object userDaoImplForMysql = applicationContext.getBean("UserDaoImplForMysql");
        System.out.println(userDaoImplForMysql);
        System.out.println("===========================================");

     /*   ClassPathXmlApplicationContext classPathXmlApplicationContext
                = new ClassPathXmlApplicationContext("bean.xml");*/

        //根据public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
        //        this(configLocations, true, (ApplicationContext)null);
        //    }
        //所以后面可以直接跟着写,"bean.xml"  可以指定多个路径
        Object vip = applicationContext.getBean("vip");
        Object userDaoImplForMysql1 = applicationContext.getBean("UserDaoImplForMysql");
        System.out.println(userDaoImplForMysql1);
        System.out.println(vip);
        System.out.println("==========");
        Object vip0 = applicationContext.getBean("vip0");
        System.out.println(vip0);
        System.out.println("----------------------------");
//        Object nowTime = applicationContext.getBean("nowTime");
//        Date nowTime = (Date)applicationContext.getBean("nowTime");
        //不想强制转换可以这样做
        Date nowTime = applicationContext.getBean("nowTime", Date.class);
        System.out.println(nowTime);

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:ss:SSS");
        String format = simpleDateFormat.format(nowTime);
        System.out.println("北京时间现在是:"+format);

        System.out.println("=====================");
        //强转之后可以调用UserDaoImplForMysql的方法
        UserDaoImplForMysql userDaoImplForMysql2 = applicationContext.getBean("UserDaoImplForMysql", UserDaoImplForMysql.class);
        userDaoImplForMysql2.insert();

    }
}

BeanFactory是IoC容器的顶级接口


***OCP***
Open-Closed Principle软件设计中的“开-闭原则”
这个原则最早是由Bertrand Meyer提出,英文的原文是:Software entities should be open for extension,
but closed for modification.
意思是说,一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,
换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为.
满足OCP的设计给系统带来两个无可比拟的优越性.
1.通过扩展已有的软件系统,可以提供新的行为,以满足对软件的新需求,使变化中的软件系统有一定的适应性和灵活性.
2.已有的软件模块,特别是最重要的抽象层模块不能再修改,这就使变化中的软件系统有一定的稳定性和延续性.
例如：
编程模式中的工厂模式的“工厂方法”支持OCP原则
对扩展开放 对修改关闭


***DIP***
依赖倒置原则（dependency inversion principle）
面向接口编程 面向抽象编程 不要面向具体编程
降低耦合度 提高扩展力
表现层 业务层 持久层不再从上往下依赖


***IOC***
核心概念
1. IoC（Inversion of Control）控制反转
使用对象时，由主动new产生对象转换成，从外部提供对象
在这个过程中，对象的创建控制权由程序转移到外部，此思想称为控制反转。用来减低计算机代码之间的耦合度。


***Spring框架***
  *Spring框架实现了控制反转IoC这种思想。
   Spring可以帮你new对象
   Spring框架可以帮你维护对象和对象之间的关系。
  *Spring是一个实现了IoC思想的容器。
  *控制反转的实现方式很多种，其中比较重要的依赖注入（Dependency Injection，简称DI），
  *还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，
  *由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
  **依赖注入DI 常见的两种方式
   ！！！set注入、构造方法注入！！！
   依赖：A对象与B对象之间的关系
   注入：是一种手段 通过这种手段可以让A对象与B对象产生关系。
   依赖注入：对象A和对象B之间的关系，靠注入的手段来维护，为注入包括：set注入和构造器注入

***本节术语
 OCP：开闭原则
 IoC：控制反转
 DIP：依赖倒置
 DI：依赖注入

个人总结使用对象时通常是使用new但是如此耦合性太搞了使用spring就是将对象的创建控制权全部交给Spring来处理我们只需要设置spring的东西即可

原文地址：http://www.cnblogs.com/lps1944900433/p/16908292.html

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，请务用于商业用途! 3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！ 8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性

排行榜展示

3D打印机glb模型下载-机械glb模型

树glb模型下载-树2

水稻glb模型下载-水稻1

变电箱1glb模型下载-机械glb模型

树glb模型下载-树3

模型

树glb模型下载-树1