38Spring

最新推荐文章于 2024-07-12 15:51:39 发布

置顶 weixin_aqing

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量77

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_aqing/article/details/113426645

版权

目标：

掌握Spring是什么？有什么用？ ----> 业务层框架，作用：解耦。
了解工厂解耦 — 用工厂创建实例对象，手动new有什么区别
掌握IOC 控制反转
掌握DI 依赖注入
IOC + DI

一、简介

什么是Spring

Spring 是分层的Java SE/EE应用 full-stack(服务端的全栈)轻量级（跟EJB比）开源框架，以IoC(Inversion of Control控制反转，目的是解耦)和AOP(面向切面编程，本质是动态代理)为内核
- Spring家族有很多的框架，涉及到所有层（web |service |dao）
- 今天学的Spring仅仅是Spring家族里面的其中一个框架 Spring Framework (IOC + AOP)
提供了：
- 表示层Spring MVC
- 持久层Spring JDBCTemplate， Spring Data JPA
- 业务层事务管理等
能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

Spring的发展历程

1997年，IBM提出了EJB的思想
1998年，SUN制定开发标准规范EJB1.0
1999年，EJB1.1发布
2001年，EJB2.0发布
2003年，EJB2.1发布
2006年，EJB3.0发布
Rod Johnson（spring之父）
- Expert One-to-One J2EE Design and Development(2002)
  阐述了J2EE使用EJB开发设计的优点及解决方案
- Expert One-to-One J2EE Development without EJB(2004)
  阐述了J2EE开发不使用EJB的解决方式（Spring雏形）
2017年9月份发布了spring的最新版本spring 5.0通用版（GA）

Spring的优势

方便解耦，简化开发（IoC思想，第1、2天）
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。创建对象更简单！
AOP编程的支持（第3天）
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
比如：要求面面项目里，每个方法被调用时，都输出日志到控制台“2020-03-20 11:20:31执行了xxx.xx方法”
声明式事务的支持（第3天）
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。@Transactional
方便程序的测试（第1天）
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
例如：Spring整合了Junit
方便集成各种优秀框架（SSM整合，SpringMVC第2天）
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
降低JavaEE API的使用难度(第3天)
Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
Java源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。

Spring的体系结构

二

、工厂模式解耦（理解）

耦合性问题

耦合性：程序之间的依赖性。
- 编译期依赖：编译时必须提供依赖的类，否则编译不通过。
  - UserDao dao = new UserDaoImpl();
- 运行期依赖：运行时必须提供依赖的类，否则不能运行。
  - UserDao dao = Class.forName(“com.itheima.dao.impl.UserDaoImpl”).newInstance();
- 应当减少编译期依赖，使用运行期依赖
耦合性越强，维护成本（时间成本&精力成本）就越高
开发时要求：高内聚，低耦合
- 低耦合：耦合度很低，代码与代码之间耦合度很低。
- 高内聚：把具有一样功能的代码，尽可能靠拢起来。一个业务有很多的方法，这些方法要尽可能靠在一块。方便管理，维护。
  类与类之间的内聚
  - 注册 ---- RegisterServlet
  - 登录 — LoginServlet
  - 更新用户 — UpdateUserServlet
  - 用户 ----- UserServlet
    方法与方法之间的内聚
    每个方法里面都有乱码解决…两句话 ---- 过滤器。。

1.1 耦合性问题现象

在web开发中，服务端通常分为三层：web层、service层、dao层
- web层调用service层完成功能：需要new一个Service对象
  - UserService userService = new UserService();
  - 真正开发的时候是面向接口编程。
    - UserService userService = new UserServiceImpl();
- service层调用dao层操作数据库：需要new一个dao对象
  - UserDao userDao = new UserDao();
  - 真正开发的时候是面向接口编程。
    - UerDao userDao = new UserDaoImpl;
    - UserDao userDao = new UserDaoImpl02();
三层之间的耦合性比较强：存在编译期依赖
- service里写死了创建某一个dao对象：一旦dao对象换了，就需要修改service的源码
- web里写死了创建某一个service对象：一旦service对象换了，就需要修改web的源码

1.2 解耦的思路

可以使用反射技术，代替new创建对象，避免编译期依赖
Class clazz = Class.forName(“全限定类名”);
Object obj = clazz.newInstance();
再把全限定类名提取到配置文件中（xml或properties），读取配置文件信息来反射创建对象
//读取配置文件，得到要创建对象的全限定类名；再通过反射技术创建对象
String className = …;
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();

使用工厂模式解耦

需求描述

UserService提供用户相关的功能，需要调用UserDao完成数据库操作
使用工厂模式+配置文件的方式，降低它们之间的耦合性

需求分析

需求实现

创建项目，导入依赖

<dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
       </dependency>
   </dependencies>


2. dao层代码

   package com.itheima.dao;
   
   public interface UserDao {
       void add();
   }
   package com.itheima.dao.impl;
   
   import com.itheima.dao.UserDao;
   
   public class UserDaoImpl  implements UserDao {
       public void add() {
           System.out.println("UserDaoImpl...add");
       }
   }

service层代码
package com.itheima.service;

public interface UserService {
void add();
}

package com.itheima.service.impl;

import com.itheima.dao.UserDao;
import com.itheima.factory.BeanFactory;
import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {
    public void add() {
        try {
            System.out.println("UserServiceImpl...add..");

            //UserService userService = new UserService(); 最早的代码
            //有接口的代码
            //UserService userService = new UserServiceImpl();

            //使用工厂来解耦。
            UserDao userDao = (UserDao) BeanFactory.getBean("ud");
            userDao.add();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

配置文件beans.properties
配置文件写在 resources目录面
ud=com.itheima.dao.impl.UserDaoImpl
us=com.itheima.service.impl.UserServiceImpl
工厂类BeanFactory

package com.itheima.factory;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;

public class BeanFactory {

    private static Map<String ,String> map = new HashMap<>();

    //1. 在静态代码块里面读取配置文件
    static {
        //1.1 读取resources下面的bean.properties文件
        ResourceBundle bundle = ResourceBundle.getBundle("bean");

        //1.2 获取文件里面所有key
        Enumeration<String> keys = bundle.getKeys();

        //1.3 遍历所有的key
        while(keys.hasMoreElements()){
            String className = keys.nextElement(); // ud
            String classPath = bundle.getString(className); // com.itheima.dao.impl.UserDaoImpl

            //1.4 把key 和 类的全路径对应关系，使用map来存。
            map.put(className , classPath);
        }
    }

    //2. 使用一个方法专门提供实例
    public static Object getBean(String beanName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //2.1 从map里面取出来类的全路径
        String className = map.get(beanName);

        //2.2 如果能取出来，表示有，那么就创建实例返回
        if(className != null){
            return Class.forName(className).newInstance();
        }

        //2.3 如果没有就返回null
        return null;
    }
}

小结

首先得有接口和实现类： UserDao 和 UserDaoImplement ， UserService 和 UserServiceImpl
使用properties配置文件来记录，别名和实现类的全路径
定义一个工厂类
1. 在静态代码块里面读取配置文件，使用map集合来存映射关系
2. 定义一个静态方法，只要有人来获取实例，那么就从map集合里面取出来全路径
3. 使用反射技术来构建实例返回。
IoC思想

IoC：Inversion of Control，控制反转。是指把创建对象的控制权交给框架：要想得到一个对象，由原来的主动创建对象，变成自己被动接收框架创建的对象。
IoC是Spring的核心思想之一
作用：用于降低程序间的耦合性

三、控制反转IoC【重点】

0 . IOC

什么是IOC

控制反转，把对象的创建工作交给框架（工厂），我们不需要自己去new这个对象，只管问工厂要。由原来的主动创建对象，变成自己被动接收框架创建的对象。

IOC的作用

IOC是Spring的核心之一，作用就是为了解耦，降低程序，代码间的耦合度。

快速入门

需求描述

有UserDao接口和UserDaoImpl实现类
通过Spring容器得到UserDaoImpl的实例对象（IoC方式）

开发步骤

创建Maven项目，导入依赖坐标：Spring的依赖坐标
编写dao接口UserDao及实现UserDaoImpl
创建Spring核心配置文件，并配置UserDaoImpl （作用类似bean.properties）
测试：使用Spring的API，获取Bean实例对象

需求实现

创建Maven项目，导入依赖坐标

org.springframework spring-context 5.1.2.RELEASE junit junit 4.12 ```


3. 编写dao层和service层代码

- dao层接口UserDao


2. 编写dao层和service层代码

- dao层接口UserDao

package com.itheima.dao;

public interface UserDao {
void add();
}

service层接口UserService

package com.itheima.service;

public interface UserService {
    void add();

    void delete();
}


service层实现类UserServiceImpl

package com.itheima.service.impl;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {

    //4. 不想new对象了，想让spring注入进来等号的右边。
    //private  UserDao userDao = new UserDaoImpl();

    //5. 想要让srping完成userDao的赋值工作，就使用一个set方法来完成。
    private  UserDao userDao;

    public void setUserDao(UserDao userDao) {
        System.out.println("spring来调用set方法赋值了");
        this.userDao = userDao;
    }

public void add() {
System.out.println(“userServiceImpl…add…”);

//1. 最早的代码
//UserDao userDao = new UserDao();

//2. 有接口的代码

// UserDao userDao = new UserDaoImpl();
//userDao.add();

//3. 把userDao 提取上去，只要做一个对象即可
userDao.add();

}

public void delete() {
    System.out.println("userServiceImpl..delete...");

    //2. 有接口的代码
    //UserDao userDao = new UserDaoImpl();
    //userDao.delete();
}

}

创建Spring核心配置文件，并配置bean和依赖注入

<?xml version="1.0" encoding="UTF-8"?>



<!--把两个实现类都交给spring来管理-->

<!--把service交给spring管理，在这个类里面有一个属性叫做userDao 它需要完成赋值的工作，
这个赋值的工作就交给spring来完成，拿谁来赋值？ 拿名字叫做ud的bean 来赋值
其实就是拿UserDaoImpl的对象来赋值-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
    <property name="userDao" ref="ud"/>
</bean>

```


4. 使用Spring的API，测试

package com.itheima.test;

import com.itheima.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUserService {

    @Test
    public void test(){

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

        UserService us =  context.getBean("userService" , UserService.class);
        us.add();
    }
}

小结


2. 三种常见注入方式

set方法注入（最常用）

1) 介绍

在类中提供需要注入的成员（依赖项）的set方法，在配置文件中注入属性的值

```

property标签：用在bean标签内部，表示要给某一属性注入数据
- name：属性名称
- value：要注入的属性值，注入简单类型值
- ref：要注入的属性值，注入其它bean对象

优势：创建bean对象时没有明确的限制，可以使用无参构造直接创建

缺点：如果某个成员必须有值，则获取对象时，有可能set方法未执行

示例

dao

public class UserDaoImpl02 implements UserDao {

    public void add() {
        System.out.println("UserDaoImpl02...add");
    }
}

service

public class UserServiceImpl02 implements UserService {

    //1. 表示UserServiceImpl02 有一个属性|成员
    private UserDao userDao ;//= new UserDaoImpl();
    private String address;

    //2. 提供一个set方法，以便spring完成注入。
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void add() {
        System.out.println("UserServiceImpl02..add..." +address);
        userDao.add();

    }


    public void delete() {
        System.out.println("UserServiceImpl02..delete...");
    }
}

xml

<!--3. 把对象交给spring 来管理-->
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl02"/>

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl02">
    <!--
    4.给属性注入值
    property 指的就是UserServiceImpl02类的一个属性 userDao
    ref :引用对象，其实就是使用哪个bean注入进来，要写的是bean的id值-->
    <property name="userDao" ref="userDao"/>

    <property name="address" value="深圳"/>
</bean>

构造方法注入

介绍


在类中提供构造方法，构造方法的每个参数就是一个依赖项，通过构造方法给依赖项注入值。

```

name：构造参数的名称
type：构造参数的类型
index：构造参数的索引
value：要注入的值，注入简单类型值
ref：要注入的值，注入其它bean对象

优势：在获取bean对象时，注入数据是必须的操作，否则无法创建成功。

缺点：改变了bean对象的实例化方式，如果在创建对象时用不到这些数据，也必须要提供

示例

dao

public class UserDaoImpl03 implements UserDao {

    public void add() {
        System.out.println("UserDaoImpl03...add");
    }
}

service

public class UserServiceImpl03 implements UserService {

    private UserDao userDao;
    private String address;


    public  UserServiceImpl03(){

    }
    public UserServiceImpl03(UserDao userDao, String address) {
        System.out.println("使用有参构造进行赋值");
        this.userDao = userDao;
        this.address = address;
    }

    public void add() {
        System.out.println("UserServiceImpl03..add..." +address);
        userDao.add();
    }


    public void delete() {
        System.out.println("UserServiceImpl03..delete...");
    }
}

xml

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl03"/>

    <!--默认情况下，spring创建一个类的对象，走的是无参构造。
    如果一定要让它走有参构造，去完成依赖注入的功能，也可以-->
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl03">
        <constructor-arg name="address" value="北京"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>

p名称空间注入

介绍

p名称空间注入，本质仍然是set方法注入

在xml中引入p名称空间的约束

然后通过p:属性名称="“来注入简单数据、使用p:属性名称-ref=”"注入其它bean对象，它的本质仍然是set方法注入

<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
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="" class="" p:属性名="简单值" p:属性名-ref="bean的id"></bean>
    
</beans>

示例

dao

public class UserServiceImpl04 implements UserService {

    private UserDao userDao;
    private String address;

    //使用p名称空间方式来注入 ,背后使用的还是set方法。所以还是要提供set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setAddress(String address) {
        this.address = address;
    }



    public void add() {
        System.out.println("UserServiceImpl04..add..." +address);
        userDao.add();
    }


    public void delete() {
        System.out.println("UserServiceImpl04..delete...");
    }
}

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl04"/>
   <!-- p名称空间的注入写法，背后其实还是走set方法
    如果是这个属性要的是普通的值：p:属性名=""
    如果这个属性要的是对象类型： p:属性名-ref=""-->
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl04" p:address="深圳湾2号" p:userDao-ref="userDao"/>
</beans>

小结

注入方式有三种，set方法，构造方法注入，p名称空间
最常用的是set方法。
以后如果使用注解了，方法也不需要写了。
注入集合数据

介绍

前边我们介绍了如何注入简单数据类型和bean对象，但是在实际开发中，可能会需要给集合属性注入数据，比如：给数组、List、Set、Map等注入数据

示例

有UserDaoImpl需要注入数据

public class UserDaoImpl implements UserDao {
    private String[] arr;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    // get/set...

    public void show(){
        System.out.println(Arrays.toString(this.arr));
        System.out.println(this.list);
        System.out.println(this.set);
        System.out.println(this.map);
        System.out.println(this.properties);
    }
}

配置注入数据

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
    <!--给数组注入数据-->
    <property name="arr">
        <array>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </array>
    </property>
    <!--给list注入数据-->
    <property name="list">
        <list>
            <value>a1</value>
            <value>b1</value>
            <value>c1</value>
        </list>
    </property>
    <!--给set注入数据-->
    <property name="set">
        <set>
            <value>a2</value>
            <value>b2</value>
            <value>c2</value>
        </set>
    </property>
    <!--给map注入数据-->
    <property name="map">
        <map>
            <entry key="a3" value="a3"/>
            <entry key="b3" value="b3"/>
            <entry key="c3" value="c3"/>
        </map>
    </property>
    <!--给properties注入数据-->
    <property name="properties">
        <props>
            <prop key="a4">a4</prop>
            <prop key="b4">b4</prop>
            <prop key="c4">c4</prop>
        </props>
    </property>
</bean>

总结

spring的IOC & DI
什么是spring
1. 是业务逻辑层的一套框架，能够无缝对接|整合web层和dao层其他框架，它的核心是IOC 和 AOP。
什么时候IOC
1. 控制反转，就是把类交给spring托管，让spring创建这个类的对象
2. Spring创建对象的时候，默认执行的是类的无参构造，当然也可以让它走有参构造。
DI
1. 什么是DI
  1. 依赖注入，把属性需要用到的对象赋值|注入进来。
2. 注入的方式
  1. 三种方式： set方式 | 构造方式 | p名称空间（背后也是set）
3. 依赖注入，最常用的是注入对象类型，使用set方法。
crud
1. 整合dbutils
2. 整合c3p0
spring整合Junit
1. 在做单元测试的时候，获取bean的时候更加简单。

weixin_aqing

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
38Spring

目标：掌握Spring是什么？有什么用？ ----> 业务层框架，作用：解耦。了解工厂解耦 — 用工厂创建实例对象，手动new有什么区别掌握IOC 控制反转掌握DI 依赖注入IOC + DI一、简介什么是SpringSpring 是分层的Java SE/EE应用 full-stack(服务端的全栈)轻量级（跟EJB比）开源框架，以IoC(Inversion of Control控制反转，目的是解耦)和AOP(面向切面编程，本质是动态代理)为内核Spr..
复制链接

扫一扫