spring基础:什么是框架,框架优势,spring优势,耦合内聚,什么是Ioc,IOC配置,set注入,第三方资源配置,

知识点梳理

课堂讲义

1)Spring简介

1.1)什么是框架

• 源自于建筑学，隶属土木工程，后发展到软件工程领域

  

• 软件工程中框架的特点：

  • 经过验证

  • 具有一定功能

  • 半成品

1.2)框架的优势

• 提高开发效率

• 增强可重用性

• 提供编写规范

• 节约维护成本

• 解耦底层实现原理

既然软件工程中的框架有这么多的优势，那广大软件工程师就就很有必要去学习和使用框架。

 

1.3)Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架。

分层：针对三层架构设计: Controller层（WEB层）-> Service层（业务层）-> 数据层（DAO）

full-stack（全栈）：Spring功能非常强大，能够服务于Java开发过程中的各个层面

轻量级：资源消耗较低，运行速度较快

1.4)Spring的体系结构

两大核心：

• IoC：控制反转

• AOP：面向切面编程（一种编程思想）

1.5)Spring的发展历史

作者：Rod Johnson 罗宾·约翰逊

 

1.6)Spring优势

SPRING的优势
方便解耦，简化开发	第一天
方便集成各种优秀框架，比如MyBatis	第一天
方便程序的测试，集成JUnit	第二天
AOP编程的支持	第三天
声明式事务的支持	第四天
Java源码是经典学习范例	长期学习

 

2)IoC简介

2.1)回顾数据库查询

2.2)耦合与内聚

• 耦合（Coupling）：用于衡量软件中各个模块之间的互联程度。举例说明 

• 内聚（Cohesion）：代码书写过程中单个模块内部各组成部分间的联系，用于衡量软件中各个功能模块内部的功能联系，比如UserServiceImpl中的增删查改需要写到一个类中

• 优质程序代码的制作原则：高内聚，低耦合

  保证同一个模块内的各个功能之间要高度紧密，但是尽量降低多个模块之间的相互依赖

2.3)工厂模式发展史

• UserServiceImpl中需要调用userDao对象：自己通过new UserDaoImpl()产生对象

• UserServiceImpl中需要调用userDao对象：通过UserDao工厂类获取

• UserServiceImpl中需要调用userDao对象：在工厂类中读取配置文件通过反射产生UserDao的对象

2.4)IoC衍生过程

2.5)IoC概念

• IoC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源。举例

• Spring控制的资源将全部放置在Spring容器中，该容器称为IoC容器

• IoC是面向对象编程的一种设计原则，可以用来降低代码之间的耦合度

3)入门案例(重点)

3.1)案例环境说明

• 模拟三层架构中表现层调用业务层功能

• 表现层：UserApp（使用main方法）模拟UserServlet

• 业务层：UserService

3.2)IoC入门案例制作步骤

1.导入spring坐标（5.1.9.RELEASE）

2.编写业务层接口与实现类

3.建立spring配置文件：resourcesapplicationContext.xml

4.配置所需资源（Service）为spring控制的资源

5.表现层（App）通过spring获取资源（Service实例）

3.2.1)导入Spring坐标

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

3.2.2)编写业务层接口和实现类

public interface UserService {
    //业务方法  
    void save();
}

public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("user service running...");
    }
}

3.2.3)编写Spring配置文件

srcmain esourcesapplicationContext.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">
    
</beans>

3.2.4)配置UserServiceImpl为Spring控制的资源

<!-- 1.创建spring控制的资源-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>

3.2.5)模拟表现层调用业务层

public class UserApp {
    public static void main(String[] args) {
        //2.加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //3.获取资源
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

 

4)IoC配置（XML格式）

4.1)bean

• 名称：bean

• 类型：标签

• 归属：beans标签

• 作用：定义spring中的资源，受此标签定义的资源将受到spring控制

• 基本属性：

  <bean id="userService" name="userService1, userService2" class="com.itheima.service.impl.UserServiceImpl"/>

  id：bean的名称，通过id值获取bean

  class：bean的类型

  name：bean的名称，可以通过name值获取bean，用于多人共同开发时给bean起别名

4.2)bean属性scope

• 名称：scope（范围，作用域）

• 类型：属性

• 归属：bean标签

• 作用：定义bean的作用范围

• 格式：

  <bean scope="singleton" />

• 取值：

  • singleton：设定创建出的对象保存在spring容器中，是一个单例的对象

  • prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象

  • request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

  public class UserServiceImpl implements UserService {
  ​
      //通过构造方法判断实例化了几次
      public UserServiceImpl(){
          System.out.println(" constructor is running...");
      }
  }

   

4.3)bean生命周期 

• 名称：init-method，destroy-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象在初始化或销毁时完成的工作

• 格式：

  <bean id="userService3" init-method="init" destroy-method="destroy"
        class="com.itheima.service.impl.UserServiceImpl"/>

• 取值：bean对应的类中对应的具体方法名

• 在UserServiceImpl中编写init()和destroy()

  public void init(){
      System.out.println("init....");
  }
  ​
  public void destroy(){
      System.out.println("destroy....");
  }

• 如果需要执行destroy()，必须手动调用ClassPathXmlApplicationContext对象的close的方法

  ctx.close();

  public class UserApp {
      public static void main(String[] args) {
          ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
          "applicationContext.xml");
          UserService userService = (UserService) ctx.getBean("userService5");
          userService.save();
          ctx.close();
      }
  }

• 注意事项：

  • 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次

  • 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次

  • 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次

  • 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

   

4.4)bean对象创建方式(了解)

(1)使用静态工厂：factory-method

package com.itheima.service;
​
public class UserServiceFactory {
​
    public static UserService getService(){
        System.out.println("factory create object...");
        return new UserServiceImpl();
    }
}

• 名称：factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用静态工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

• 注意事项：class属性必须配置成静态工厂的类名

  <bean id="userService5" class="com.itheima.service.UserServiceFactory"
        factory-method="getService" />

• 取值：工厂bean中用于获取对象的静态方法名

(2)使用实例工厂：factory-bean，factory-method

package com.itheima.service;
​
public class UserServiceFactory2 {
​
    public UserService getService(){
        System.out.println(" instance factory create object...");
        return new UserServiceImpl();
    }
}

• 名称：factory-bean，factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用实例工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <!--实例工厂对应的bean-->
  <bean id="userServiceFactory" class="com.itheima.service.UserServiceFactory2"/>
  
  <!--实例工厂创建bean，依赖工厂对象对应的bean-->
  <bean id="userService" factory-bean="userServiceFactory" factory-method="getService"/>

• 取值：工厂bean中用于获取对象的实例方法名

• 注意事项：

  • 使用实例工厂创建bean首先需要将实例工厂配置bean，交由spring进行管理

  • factory-bean是实例工厂的beanId

   

4.5)DI

• IoC（Inversion Of Control）控制反转

  Spring反向控制应用程序所需要使用的外部资源

• DI（Dependency Injection）依赖注入

  应用程序运行依赖的资源由Spring为其提供，资源进入应用程序的方式称为注入

• IoC与DI的关系：同一件事站在不同角度看待问题

 

4.6)set注入(重点)

• 名称：property

• 类型：标签

• 归属：bean标签

• 作用：使用set方法的形式为bean提供资源

• 格式：

  <bean>
  	<property />
  </bean>

• 基本属性：

  • 引用类型：自定义类产生的对象，使用ref指定

  • 非引用类型：基本数据类型(int, char,...)和特殊类型String，使用value指定

  <!--非引用类型注入-->
  <property name="propertyName" value="propertyValue" />
  
  <!--引用类型注入-->
  <property name="propertyName" ref="beanId"/>

name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范：此名称是set方法对应名称）

value：设定非引用类型属性对应的值，不能与ref同时使用

ref：设定引用类型属性对应bean的id ，不能与value同时使用

• 使用set注入

  1. 在UserServiceImpl中添加三个属性，并添加set方法

     public class UserServiceImpl implements UserService {
     
         /*
             1. 基本数据类型：int, char
             2. 特殊类型：String
             3. 引用类型：自定义类产生的对象
          */
         private int num;
         private String version;
     
         private UserDao userDao;
     
         //1.对需要进行诸如的变量添加set方法
         public void setNum(int num) {
             this.num = num;
         }
     
         public void setVersion(String version) {
             this.version = version;
         }
     
         public void setUserDao(UserDao userDao) {
             this.userDao = userDao;
         }
     
         public void save() {
             System.out.println("user service running..."+num+" "+version);
             userDao.save();
         }
     }

  2. 在applicationContext.xml中完成set注入的配置

     <!--2.将要注入的资源声明为bean-->
     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
     
     <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
         <!--3.将要注入的引用类型的变量通过property属性进行注入，对应的name是要注入的变量名，使用ref属性声明要注入的bean的id-->
         <!--reference 引用类型-->
         <!--setUserDao()-->
         <property name="userDao" ref="userDao"/>
         <!--setNum-->
         <property name="num" value="666"/>
         <!--setVersion-->
         <property name="version" value="itheima"/>
     </bean>

  3. 获取userService验证是否注入成功

     ApplicationContext ctx =
             new ClassPathXmlApplicationContext("applicationContext.xml");
     UserService userService = (UserService) ctx.getBean("userService");
     userService.save();

• 易错点：类中必须写set方法

• xml中的<property />== 代码中的setXxx()

小结

1. 类中必须写set方法

2. bean中使用property标签注入属性

3. name表示注入的属性名

4. 引用类型：使用ref进行注入

5. 其他：使用value进行赋值注入

 

4.7)构造方法注入（了解）

• 名称：constructor-arg

• 类型：标签

• 归属：bean标签

• 作用：使用构造方法的形式为bean提供资源，兼容早期遗留系统的升级工作

• 格式：

  <bean>
  	<constructor-arg />
  </bean>

• 基本属性：

  <constructor-arg name="argsName" value="argsValue" />

  • name：对应bean中的构造方法所携带的参数名

  • value：设定非引用类型构造方法参数对应的值，不能与ref同时使用

• 其他属性：

  • type ：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验

    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <!--根据类型进行匹配-->
        <constructor-arg type="java.lang.String" value="itcast"/>
        <constructor-arg type="int" value="666666"/>
        <constructor-arg type="com.itheima.dao.UserDao" ref="userDao"/>
    </bean>

  • index ：设定构造方法参数的位置，用于按位置匹配参数，参数index值从0开始计数

    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
        <!--根据index进行匹配-->
        <!--argument 参数-->
        <constructor-arg index="1" value="123"/>
        <constructor-arg index="2" value="com.mysql.jdbc.Driver"/>
        <constructor-arg index="0" value="root"/>
    </bean>

 

4.8)集合类型数据注入

• 名称：array，list，set，map，props

• 类型：标签

• 归属：property标签 或 constructor-arg标签

• 作用：注入集合数据类型属性

• 格式：

(1)集合类型数据注入——list

<!--setAl()-->
<property name="al">
    <list>
        <value>itheima</value>
        <value>66666</value>
    </list>
</property>

(2)集合类型数据注入——props

<property name="properties">
    <props>
        <prop key="name">itheima666</prop>
        <prop key="value">666666</prop>
    </props>
</property>

(3)集合类型数据注入——array （了解）

<property name="arr">
    <array>
        <value>123456</value>
        <value>66666</value>
    </array>
</property>

(4)集合类型数据注入——set（了解）

 <property name="hs">
     <set>
         <value>itheima</value>
         <value>66666</value>
     </set>
</property>

(5)集合类型数据注入——map（了解）

<property name="hm">
    <map>
        <entry key="name" value="itheima66666"/>
        <entry key="value" value="6666666666"/>
    </map>
</property>

扩展知识

将引用类型注入到map当中，使用value-ref属性

<map>
    <entry key="name" value="itheima66666"/>
    <entry key="value" value="6666666666"/>

    <entry key="userDao" value-ref="userDao" />
</map>

 

4.9)使用p命名空间简化配置（了解）

• 名称：p:propertyName，p:propertyName-ref

• 类型：属性

• 归属：bean标签

• 作用：为bean注入属性值

• 格式：

  <bean p:propertyName="propertyValue" p:propertyName-ref="beanId"/>

• 注意：使用p命令空间需要先开启spring对p命令空间的的支持，在beans标签中添加对应空间支持

  <beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:p="http://www.springframework.org/schema/p"       xsi:schemaLocation="http://www.springframework.org/schema/beans     https://www.springframework.org/schema/beans/spring-beans.xsd">

• 示例：

  <bean
      id="userService"
      class="com.itheima.service.impl.UserServiceImpl"
      p:num="888"
      p:version="1.1"
      p:userDao-ref="userDao"
      p:bookDao-ref="bookDao"
    />

• 不建议使用

4.10)SpEL （了解）

JSP中的EL表达式：${key}

• Spring提供了对EL表达式的支持，统一属性注入格式

• 类型：属性值

• 归属：value属性值

• 作用：为bean注入属性值

• 格式：

  <property name="name" value="#{value}"/>

• 注意：所有属性值不区分是否引用类型，统一使用value赋值

• 所有格式统一使用 value=“#{}”

  • 常量 #{10} #{3.14} #{2e5} #{‘itcast’}

  • 引用bean #{beanId}

  • 引用bean属性 #{beanId.propertyName}

  • 引用bean方法 beanId.methodName().method2()

  • 引用静态方法 T(java.lang.Math).PI

  • 运算符支持 #{3 lt 4 == 4 ge 3}

  • 正则表达式支持 #{user.name matches‘[a-z]{6,}’}

  • 集合支持 #{likes[3]}

• 示例：

   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
       <property name="userDao" value="#{userDao}"/>
       <property name="bookDao" value="#{bookDao}"/>
       <property name="num" value="#{666666666}"/>
       <property name="version" value="#{'itcast'}"/>
  </bean>

• 不建议使用

4.11)properties文件(重点)

• Spring提供了读取外部properties文件的机制，使用读取到的数据为bean的属性赋值

• 操作步骤

  1.准备外部data.properties文件，放置在srcmain esources目录下

  #系统环境变量中存在username,在cmd中使用echo %username%查看
  #username=root
  username=root
  pwd=root

  2.开启context命名空间支持

  <?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:p="http://www.springframework.org/schema/p"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          https://www.springframework.org/schema/context/spring-context.xsd">

3.加载指定的properties文件

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

4.使用加载的数据

<property name="propertyName" value="${propertiesName}"/>

• 注意：如果需要加载多个properties文件，可以使用*.properties表示加载所有的properties文件

• 注意：读取数据使用${propertiesName}格式进行，其中propertiesName指properties文件中的属性名

• 注意和系统环境变量的冲突

  cmd 
  echo %JAVA_HOME%
  echo %username%

  扩展知识：使用local-override属性覆盖操作系统中的环境变量

  <context:property-placeholder location="classpath:filename.properties" 
                                local-override="true" />

 

4.12)多配置文件

Spring多配置文件的使用方式：使用import即可。

• 名称：import

• 类型：标签

• 归属：beans标签

• 作用：在当前配置文件中导入其他配置文件中的项

• 第一种导入方式（常用）：使用import标签配置resource：加载的配置文件名

  <beans>
  	<import resource="applicationContext-user.xml"/>
  </beans>            

• 第二种方式Spring容器加载多个配置文件（了解）

  new ClassPathXmlApplicationContext("config1.xml","config2.xml");

• Spring容器中的bean定义冲突问题

  • 同id的bean，后定义的覆盖先定义的

  • 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

  • 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

4.13)ApplicationContext(了解)

使用BeanFactory

Resource res = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(res);
//UserService userService = (UserService)bf.getBean("userService");

 

4.14)第三方资源配置(重点)

• 回顾之前Druid使用方式

  //获取配置文件的流对象
  InputStream is = DruidTest1.class.getClassLoader().getResourceAsStream("druid.properties");
  
  //1.通过Properties集合，加载配置文件
  Properties prop = new Properties();
  prop.load(is);
  
  //2.通过Druid连接池工厂类获取数据库连接池对象
  //driverClassName=com.mysql.jdbc.Driver
  //url=jdbc:mysql://192.168.59.129:3306/db14
  //username=root
  //password=itheima
  DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

• 引入Druid坐标

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

• 使用Spring配置Druid数据源

  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
      <property name="username" value="root"/>
      <property name="password" value="root"/>
  </bean>

 

5)综合案例(重点)

5.1)案例介绍

• 使用spring整合mybatis技术，完成账户模块（Account）的基础增删改查功能

• 账户模块对应字段

  • 编号：id

  • 账户名：name

  • 余额：money

5.2)案例分析

下图中标红部分需要咱们来实现

 

5.3)基础准备工作

• 环境准备：导入Spring坐标，MyBatis坐标，MySQL坐标，Druid坐标

  <dependencies>
      
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.1.9.RELEASE</version>
      </dependency>
      
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.3</version>
      </dependency>
      
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.47</version>
      </dependency>
  
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.16</version>
      </dependency>
  </dependencies>

• 业务类与接口准备

  1. 创建数据库表，并制作相应的实体类Account

  2. 定义业务层接口与数据层接口

  3. 在业务层调用数据层接口，并实现业务方法的调用

• 基础配置文件

  1. jdbc.properties

  2. MyBatis映射配置文件

5.4)整合准备工作

1.spring配置文件，加上context命名空间，用于加载properties文件

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

2.开启加载properties文件

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

3.配置数据源Druid

<!--加载druid资源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

4.定义service层bean，并使用property标签注入dao

<!--配置service作为spring的bean,注入dao-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"/>
</bean>

5.dao的bean无需定义，MyBatis会自动生成代理对象

 

5.5)整合工作

1.导入Spring整合MyBatis坐标

<!--Spring整合MyBatis坐标-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

2.将mybatis配置成spring管理的bean（SqlSessionFactoryBean），并将类型别名交由spring处理

<!--spring整合mybatis后控制的创建连接用的对象-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/> 
    <property name="typeAliasesPackage" value="com.itheima.domain"/>
</bean>

3.通过spring加载mybatis的映射配置文件到spring环境中（映射Mapper扫描工作交由spring处理）

<!--加载mybatis映射配置的扫描，将其作为spring的bean进行管理-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.itheima.dao"/>
</bean>

4.使用spring环境获取业务层bean，执行操作

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService accountService = (AccountService) ctx.getBean("accountService");

        //查询
        Account ac = accountService.findById(13);
        System.out.println(ac);

        //保存
        Account account = new Account();
        account.setName("jack");
        account.setMoney(123456.78);
        accountService.save(account);
    }
}