part1——初识spring（关键字：概念，程序的耦合及解耦，IOC，xml，properties）

最新推荐文章于 2022-08-04 17:02:31 发布
最新推荐文章于 2022-08-04 17:02:31 发布
阅读量454 收藏 1
点赞数
分类专栏： SSM框架——spring 文章标签： spring ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaok_yumian/article/details/104518902
版权

知识点

spring概述spring发展历程spring的优势spring的体系结构
编写jdbc的工程代码用于分析程序的耦合
编译期依赖

目标

能够说出spring框架的优点
描述出spring框架的体系结构
知道代码编译期的依赖

1、spring概述——spring是什么，spring的两大核心，spring的优势，spring体系机构
2、程序的耦合及解耦——案例中问题，工厂模式解耦
3、IOC概念和spring中的IOC ——spring基于xml的IOC环境搭建
4、依赖注入（Dependency Injection）

spring概述
Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
在这里插入图片描述
在实际开发中，服务器通常采用三层体系架构，分别为表示层（Web）、业务逻辑层（Service）、持久层（Dao），Spring对每一层都提供了技术支持
表示层 ——在表示层提供了与Sruts等框架的整合
业务逻辑层——在业务逻辑层可以管理事记录日志等
持久层 ——在持久层可以整合Hibernate、JdbcTempllate等技术
Spring框架的优点

  1. 非浸入式设计（不浸入被服务代码的设计，比如建了一个类，让框架对该类提供服务，但框架不会浸入该类）
  2. 方便解耦，简化开发（最主要功能）
  3. 支持AOP（新的编程方法，对面向对象的补充；旧方法：面向对象，面向方法）
  4. 支持声明式事务处理（通过几个简单配置，解决事务管理问题，基于AOP，与AOP相互关联）
  5. 方便程序测试（在不允许整个web工程的前提下对当中某个方法/类 进行测试）
  6. 方便集成各种优秀框架（表现在各层的整合，开放）
  7. 降低Java EE API的使用难度（JdbcTemplate降低jdbc连接）

Spring核心容器点此查看

程序的耦合和解耦的思路分析

知识点

程序的耦合和解耦的思路分析1	曾经代码中的问题分析
编写工厂类和配置文件
工厂模式解耦

目标

能够清楚程序中的耦合及解决耦合的思路
能够知道当前代码存在的问题
能够知道为什么要创建工厂类来创建对象并编写工厂类中的代码

耦合，程序间的依赖关系

  • 包括：类之间的依赖，方法间的依赖
    解耦：降低程序间的依赖关系
    实际开发中：应做到编译期不依赖，运行时才依赖
    解耦的思路：1、使用反射来创建对象，而避免使用new构建字。 2、通过读取配置文件来获取要创建的对象全限定类名

首先编写jdbc的工程代码用于分析程序的耦合
创建项目day01_ssey_01jdbc
配置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.it</groupId>
    <artifactId>day01_eesy_01jdbc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>



</project>

照图创建类JdbcDemol
在这里插入图片描述

package com.it.jdbc;

import javax.xml.transform.Result;
import java.sql.*;
import java.sql.ResultSet;

/*
*程序的耦合
 */
public class JdbcDemol {
    public static void main(String[] args) throws SQLException {
        //1、注册驱动
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());

        //2、获取连接
        Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy","root","123456");
        //3、获取操作数据库的预处理对象
        PreparedStatement pstm = conn.prepareStatement("select * from account");
        //4、执行SQL，得到结果集
        ResultSet rs = pstm.executeQuery();
        //5、遍历结果集
    while(rs.next()){
        System.out.println(rs.getString("name"));
    }
        //6、释放资源
        rs.close();
         pstm.close();
          conn.close();
    }
}

其中程序想要运行需要如图jar包（保证编译期的依赖），这个类中如果没有mysql的驱动将无法编译，这个特性就可以理解为程序的耦合
**在这里插入图片描述**

依赖注入

当某个java对象（调用者）需要调用另一个java对象（被调用者，即被依赖对象）时，在传统模式下，调用者通常会采用“new被调用者”的代码方式类创建对象，这种方式会导致调用者与被调用者直接的耦合性增加，不利于后期项目的升级和维护。
在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到Spring容器，控制权发生了反转，这就是Spring的控制反转。
从Spring容器的角度来看，Spring容器负责将依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入

作用：在使用Spring框架创建对象时，动态地将其所依赖的对象注入Bean组件中，其实现方式通常有两种，一种是属性setter方法注入，另一种是构造方法注入

上面的例子中在第一步编译期就开始依赖于某个类或jar包（new的东西）了，这样整个类的独立性就会非常的差。
所以开发中应该做到：编译期不依赖，运行时依赖
对于这道例题

早期我们的 JDBC 操作，注册驱动时，我们为什么不使用 DriverManager 的 register 方法，而是采用 Class.forName 的方式？
原因就是：
我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。
此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。
同时，也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改源码。
解决这个问题也很简单，使用配置文件配置。

可以吧第一步改为

//1、注册驱动
      //  DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串

这样的话forname里的就是字符串了，不再依赖于某个具体的驱动类，这样的话我们这个类 就可以做一个独立。当这样会因为没有这个驱动类而运行异常（可以编译），解决方法即是在pom.xml中加入

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

解耦的思路：1、在创建对象时，使用反射来创建对象（依赖一个字符串），而避免使用new关键字（依赖一个具体的驱动类），可以减少耦合。（缺点：因为是字符串如果今后想换其他数据库，那这个驱动还是需要改，第2步会解决）
2、通过读取文件来获取要创建的对象全限定类名。（也就是说，我们可以用一个配置文件，把“com.mysql.jdbc.Driver”这个字符串配置进去，通过读取配置文件的方式来得到要创建对象的全限定类名，然后再使用反射来创建对象）

接着我们用一个简单的三层架构的案例（javaweb学习中的案例模式）来分析一下问题存在的耦合问题
创建项目day_01eesy_02factory
按图建包，类和接口
在这里插入图片描述
其中 ui包为表现层，service为业务层，dao为持久层，包中的子包imp为接口的实现类
该项目用于模拟账户的保存
流程（Client——IAccountService——AccountServiceImpl——IAccountDao——AccountDaoImpl）
ui包下的Client类

package com.it.ui;

import com.it.service.imp.AccountServiceImpl;
import com.it.service.imp.AccountServiceImpl;
import com.it.service.IAccountService;
//一个简易的三层架构（表现层调用业务层，业务层在调用持久层）
//包含的依赖关系：1、业务层调用持久层时new了AccountDaoImpl  2、本类中调用业务层时new了AccountServiceImpl
//这种依赖关系有很强的依赖性，会使代码的依赖性很差
/**
 * 模拟一个表现层，用于调用业务层（实际开发中应是一个servlet）
 */
public class Client {
    public static void main(String[] args) {//调用业务层
        IAccountService as=new AccountServiceImpl();
        as.saveAccount();
    }


}

service包下的IAccountService接口

package com.it.service;

/**
 * 账户业务层的接口
 */
public interface IAccountService {
//一个模拟的方法

    /**
     * 模拟保存账户
     */
    void saveAccount();




}

service子包imp下的AccountServiceImpl（接口实现类）

package com.it.service.imp;

import com.it.dao.IAccountDao;
import com.it.dao.imp.AccountDaoImpl;
import com.it.service.IAccountService;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao=new AccountDaoImpl();//三层架构中业务层调用持久层
    /*上面的代码表示：
业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译
将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。*/
    public void saveAccount(){
        accountDao.saveAccount();
    }
}

dao包下的IAccountDao接口

package com.it.dao;

/**
 * 账户的持久层接口
 */
public interface IAccountDao {
    /**
     * 模拟保存账户,需要dao的实现类
     */
    void saveAccount();
}

dao子包imp下的AccountDaoImpl（接口实现类）

package com.it.dao.imp;

import com.it.dao.IAccountDao;

/**
 *
 */
public class AccountDaoImpl implements IAccountDao {
    /**
     * 账户的持久层实现类
     */
    public void saveAccount(){
        System.out.println("保存了账户");
    }
}

在这里插入图片描述
包含的依赖关系：1、业务层调用持久层时new了AccountDaoImpl 2、本类中调用业务层时new了AccountServiceImpl
这种依赖关系有很强的依赖性，会使代码的依赖性很差，需解决
采用方法：工厂模式解耦

工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来 并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件，创建和获取三层对象的类就是工厂

编写工厂类和配置文件
解决耦合第一步，编写工厂类及配置文件
首先编写工厂类和配置文件
com.it.factory.BeanFactory

package com.it.factory;

/**
 * 一个创建Bean对象的工厂（创建service和dao对象）
 * Bean：在计算机英语中有可重用组件的含义
 * javaBean用java语音编写的可重用组件
 *          不等于实体类（范围远大于实体类
 *    第一：需要一个配置文件来配置service和dao
 *          配置文件的内容：全限定类名，唯一标志的对应关系（key——value形式）
 *    第二：通过读取配置文件中配置的内容，反射创建对象
 *  配置文件可以是xml也可以是properties
 */
public class BeanFactory {
}

resources中创建bean.properties

accountService=com.it.service.imp.AccountServiceImpl
accountDao=com.it.dao.imp.AccountDaoImpl

然后工厂模式解耦（为这个工厂案例解耦）
新建Bean工厂类com.it.factoy.BeanFactory

package com.it.factory;

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

/**
 * 一个创建Bean对象的工厂（创建service和dao对象）
 * Bean：在计算机英语中有可重用组件的含义
 * javaBean用java语音编写的可重用组件
 *          不等于实体类（范围远大于实体类
 *    第一：需要一个配置文件来配置service和dao
 *          配置文件的内容：全限定类名，唯一标志的对应关系（key——value形式）
 *    第二：通过读取配置文件中配置的内容，反射创建对象
 *  配置文件可以说xml也可以说properties
 */
public class BeanFactory {
    //定义一个properties对象
    private static Properties props;
    //使用静态代码块为properties对象赋值
    static {
        try {
        //实例化对象
        props = new Properties();
        //获取流对象
        InputStream in= BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");

            props.load(in);//读取流
        } catch (IOException e) {
           throw new ExceptionInInitializerError("初始化properties失败");
        }
    }

    /**
     * 根据bean名称获取bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        Object bean=null;
        try {
            String beanPath = props.getProperty(beanName);
            //通过读取配置文件的形式来反射
            bean = Class.forName(beanPath).newInstance();//第一步：用反射的方式创建对象

        }catch (Exception e){
            e.printStackTrace();
        }
        return bean;
    }
}

修改AccountServiceImp

package com.it.service.imp;

import com.it.dao.IAccountDao;
import com.it.dao.imp.AccountDaoImpl;
import com.it.factory.BeanFactory;
import com.it.service.IAccountService;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
 //   private IAccountDao accountDao=new AccountDaoImpl();//三层架构中业务层调用持久层
 private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
    public void saveAccount(){
        accountDao.saveAccount();
    }
}

修改Client

package com.it.ui;

import com.it.factory.BeanFactory;
import com.it.service.imp.AccountServiceImpl;
import com.it.service.imp.AccountServiceImpl;
import com.it.service.IAccountService;

public class Client {
    public static void main(String[] args) {//调用业务层
        //IAccountService as=new AccountServiceImpl();
        IAccountService as= (IAccountService)BeanFactory.getBean("accountService");
        as.saveAccount();
    }


}

运行结果一致

IOC

概念：ioc即控制反转，把创建对象的权利交给框架，是框架的重要特征，并非面向对象编程的专用术语，它包括依赖注入和依赖查找
明确ioc的作用：消减计算机程序的耦合（解除代码中的依赖关系）

上面的案例是我们自己写代码，应用工厂模式实现的，当实际开发中自己写代码消耗精力，所有可以使用spring，即用spring的IOC解决程序的耦合

即用spring的IOC解决程序的耦合

知识点

spring基于XML的IOC环境搭建和入门
 ApplicationContext的三个实现类
 BeanFactory和ApplicationContext的区别

目标

能够自主搭建IOC的环境，知道导入哪些jar包
清晰知道实现类的具体功能，区别
知道BeanFactory和ApplicationContext两个接口的区别

spring基于xml的IOC环境搭建与入门案例
前期准备
使用的案例是，账户的业务层和持久层的依赖关系解决。在开始 spring 的配置之前，我们要先准备一下环境。由于我们是使用 spring 解决依赖关系，并不是真正的要做增删改查操作，所以此时我们没必要写实体类。并且我们在此处使用的是 java 工程，不是 java web 工程。

前期的准备： 官网：http://spring.io/ 下载地址：
http://repo.springsource.org/libs-release-local/org/springframework/spring
解压:(Spring 目录结构:)

  • docs :API 和开发规范.
  • libs :jar 包和源码.
  • schema :约束.

我们使用的版本是 是 spring5.0.2 。
重新创建项目day01_eesy_spring
照图建包
在这里插入图片描述
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.it</groupId>
    <artifactId>day01_eesy_03spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>


    </dependencies>



</project>

创建业务层接口(AccountService)和实现类(AccountServiceImpl)

package com.it.service;

/**
 * 账户业务层的接口
 */
public interface IAccountService {
//一个模拟的方法

    /**
     * 模拟保存账户
     */
    void saveAccount();
}


package com.it.service.imp;

import com.it.dao.IAccountDao;
import com.it.dao.imp.AccountDaoImpl;
import com.it.service.IAccountService;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

        private IAccountDao accountDao=new AccountDaoImpl();
    public void  saveAccount(){

        accountDao.saveAccount();

    }
}

创建持久层接口(AccountDao)和实现类(AccountDaoImpl)

package com.it.dao;

/**
 * 账户的持久层接口
 */
public interface IAccountDao {
    /**
     * 模拟保存账户,需要dao的实现类
     */
    void saveAccount();
}


package com.it.dao.imp;

import com.it.dao.IAccountDao;

/**
 *
 */
public class AccountDaoImpl implements IAccountDao {
    /**
     * 账户的持久层实现类
     */
    public void saveAccount(){
        System.out.println("保存了账户");
    }
}

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

    <!--把对象的创建交给spring来搭建-->
    <bean id="accountService" class="com.it.service.imp.AccountServiceImpl">

    </bean>
    <bean id="accountDao" class="com.it.dao.imp.AccountDaoImpl">

    </bean>


</beans>

测试代码：

package com.it.ui;

import com.it.dao.IAccountDao;
import com.it.service.imp.AccountServiceImpl;
import com.it.service.imp.AccountServiceImpl;
import com.it.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {
    public static void main(String[] args) {//调用业务层
        /**
         * 获取spring的IOC核心容器，并根据id获取对象
         */
    //1、获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        //2、根据id获取bean对象
        IAccountService as=(IAccountService)ac.getBean("accountService");//强转
        IAccountDao adao=ac.getBean("accountDao",IAccountDao.class);//通过字节码强转
        System.out.println(as);
        System.out.println(adao);
            as.saveAccount();


    }
}

在这里插入图片描述

呱呱钵钵鸡
关注
专栏目录
IOC 解耦合
Those who achieve great thing do not stick to trifles
05-13 572
IOC 解耦合 在ProductService中,调用dao ProductDao pDao=new ProductDaoImpl() 这里的dao是通过dbutils实现的curd,现在我们学习了 hibernate,我们编写productDaoHibImpl() 然后在service中需要修改之前的代码 修改成 ProductDao pDao=new productDaoHibImpl...
【Spring】 ——初识Spring
最新发布
冷兮雪的博客
05-29 1841
容器是⽤来容纳某种物品的（基本）装置。——来⾃：百度百科我们想想，之前我们接触的容器有哪些？List/Map -> 数据存储容器Tomcat -> Web 容器既然 Spring 是⼀个 IoC容器，重点应该是在“容器”⼆字上，那么它就具备两个最基础的功能：将对象存⼊到容器；从容器中取出对象所以Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。
spring注解关键字
井底之蛙
01-07 2387
spring注解： （1）@Controller   控制器 （2）@Autowired    按照类型匹配，可以完成对类成员变量，方法及构造函数进行标注，完成自动装配的工作   @Autowired(required=false) 在找不到匹配Bean时也不报错 （3）@Qualifier    注释指定注入bean的名称，防止冲突，可以对成员变量、方法入参、构造函数入参进行标注 （
Spring 关键字
tfx911的专栏
11-13 318
控制反转 IoC --Inversion of Control 面向方面编程AOP --Aspect-Oriented Programming SSH --Spring+Structs+Hibernate
spring重温笔记一（关键字）
jerny2017的博客
06-12 254
最初是由 Rod Johnson 编写的企业级 Java 应用程序开发框架POJOs servlet 容器代码重用依赖注入（DI） 控制反转IoC 类 A 依赖于类 B,B 将通过 IoC 被注入到类 A 中，DI 是Spring 框架的核心部分Spring 是模块化的，允许你挑选和选择适用于你的模块核心容器 core container： core bean context spELcore: ...
Spring与IoC系列三：基于XML的依赖注入测试程序di.rar
07-25
总结来说，这个"Spring与IoC系列三：基于XML的依赖注入测试程序di.rar"涵盖了Spring框架的核心特性——依赖注入，通过XML配置文件管理对象间的依赖关系，是学习和实践Spring框架不可或缺的一部分。通过学习和操作这...
面试官：IOC是如何实现解耦合的？
m0_72885838的博客
08-04 879
回想写过的图书管理系统、租房系统、电影院卖票系统都是基于原生的JavaSE、OOP，没有用到任何框架，在层与层的关系中一个类要想获得与其他类的联系主要的方式还是靠new，这就导致层与层之间、对象与对象之间的依赖性强“动一发而迁全身”。特别是在处理数据层和业务层之间时，由于对象没有统一管理导致很复杂！而Spring中的IOC就很好地解决了这一问题,降低耦合就是它的一大特色。...
Spring基础：IoC容器(1)
06-10
在“Spring基础：IoC容器(1)”这个主题中，我们将深入探讨Spring的核心组件——IoC容器，以及它如何管理对象的生命周期和依赖关系。 IoC（Inversion of Control），也称为控制反转，是一种设计模式，它将对象的创建...
Spring中IoC优点与缺点解析
08-28
2. 解耦合对象之间的依赖关系：IoC 容器可以将对象之间的依赖关系解耦合，使得对象之间的耦合度降低，从而提高了系统的灵活性和维护性。 3. 提高开发效率：使用 IoC 容器可以减少编程的步骤和时间，从而提高了开发...
理解spring关键词
mhbsoft的博客
02-25 222
IOC（Inversion of Control）控制反转，DI（Dependency Injection）依赖注入。 Spring 是一个bean容器。在bean容器中创建对象的这个过程就叫做控制反转。 一个类对象与另一个类对象之间的依赖关系，spring会将这个依赖关系自动注入进去，这个就叫做依赖注入。 DI 的实现依赖于IOC。 AOP（Aspect Oriented Programmin...
spring 中配置关键字总结
liuweihong02的专栏
01-21 1440
一、scopescope用来声明容器中的对象所应该处的限定场景或者说该对象的存活时间，Spring容器最初提供了两种bean的scope类型：singleton和prototype，但发布2.0之后，又引入了另外三种scope类型，即request、session和global session类型。不过这三种类型有所限制，只能在Web应用中使用。也就是说，只有在支持Web应用的Applicat
spring mvc 注解关键字的解释
小楼听风雨
04-23 209
扫描指定的包中的类上的注解，常用的注解有： @Controller 声明Action组件 @Service 声明Service组件 @Service("myMovieLister") @Repository 声明Dao组件 @Component 泛指组件, 当不好归类时. @RequestMapping("/menu") 请求映射 @Resource ...
Spring 程序间的耦合和解耦
Zystem
06-20 2323
1、耦合 大家可以看以下代码，jdbc的注册驱动以及连接数据库： 在这里的第一行代码，大家可以看到，这就有很大的耦合性关系，因为DriverManager依赖于new com.mysql.jdbc.Driver()对象，connection对象依赖于DriverManager，大家可以尝试一下，如果你把msql的jar包去掉，那么运行时，在编译器就出现错误。而无法到达运行期。这里的耦合说的就是一...
【Spring】程序的耦合和解耦，IoC 的概念以及原理
来日浅谈的博客
03-19 782
【Spring】程序的耦合和解耦，spring IoC 的概念以及原理1. 程序的耦合和解耦1.1 什么是程序的耦合1.2 解决程序耦合的思路1.3 工厂模式解耦2. 什么是IoC 1. 程序的耦合和解耦 1.1 什么是程序的耦合 耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块...
使用spring的IOC解决程序耦合
少营营的博客
07-02 165
使用spring的IOC解决程序耦合 官网：http://spring.io/ 下载地址： http://repo.springsource.org/libs-release-local/org/springframework/spring 解压:(Spring目录结构:) * docs :API和开发规范. * libs :jar包和源码. * schema :约...
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
框架设计--第一章 Spring的基本应用--习题答案
热门推荐
三桥君 | 人工智能领域优质创作者
02-20 1万+
一、填空题 依赖注入的作用就是在使用Spring框架创建对象时，动态的将其所依赖的对象注入到【Bean】组件中。 在使用Spring框架之后，对象的实例不再由调用者来创建，而是由【Spring容器】来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。 在Spring入门程序中只需将Spring的4个基础包以及【commons-logging】的JAR包复制到lib...
Spring IOC
乐以风的博客
11-03 227
我的目录1.Spring IOC的概念2.Spring IOC容器3.依赖注入的类型3.1构造方法注入3.2属性的setter方法注入 1.Spring IOC的概念     控制反转（Inversion of Control,IOC）是Spring框架的核心,用来消减计算机程序的耦合问题。依赖注入（DependencyInjection，DI）是IOC的另...
Spring入门指南：概念、解耦与IOC容器详解
本笔记主要聚焦于Spring 5版本，涵盖了核心概念、常用技术及jar包，以及IoC（依赖注入）容器的基础原理。 **1. Spring概念与核心部分** Spring由两个核心模块组成：**IoC（Inversion of Control，控制反转）** 和 *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值