spring学习笔记

spring学习笔记

框架： 一个java应用程序的半成品项目，该项目中对java的软件开发进行了一部分的封装和定义标准，我们使用时 只需要学习框架，则会学会使用该框架开发新项目，再开发中使用框架可以提高开发效率，有利于团队开发。

​ 缺点：

​ 1，需要导入大量的jar包,会出现版本冲突

​ 2，项目运行效率低

​ 优点：

​ 1，提高开发效率

​ 2，利于团队开发

​ 3，有利于后期的维护

springBoot mybatis —> SM

springmvc spring mybatis —> SSM

struts2 spring hibernate —> SSH

目标：

​ spring简介

​ spring核心

​ IOC/DI

​ AOP

​ 声明式事务管理

​ jdbctemplete

spring简介

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

轻量级框架, Java EE的春天,当前最主流框架。

IOC/DI 反转控制 依赖注入

AOP 面向切面编程

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 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造 成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可 以更专注于上层的应用。

AOP 编程的支持

通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。

声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理， 提高开发效率和质量。

方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可 做的事情。

方便集成各种优秀框架

Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz 等）的直接支持。

降低 JavaEE API******的使用难度

Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的 使用难度大为降低。

Java******源码是经典学习范例

Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以 及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

通俗的说：

​ 使现有技术更加易用,推进编码最佳实践

​ 老技术新用法

​ 降低耦合性【亲密度】

七大部分组成

IoC容器【控制翻转/依赖注入】

AOP实现

数据访问支持

简化JDBC/ORM 框架

声明式事务

spring的web支持

spring的单元测试

Spring在mvc中的江湖位置：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8w5ZyGJ-1622703393122)(D:\王者班高级资料\笔记\02spring\typoraimg\wps2.jpg)]

耦合度

耦合度是再java中，类与类之间的关系，可以是 亲密度.

程序编程思想： 高内聚，低耦合

最好是再编译期不存在问题即可

public class TestJDBC {
   
    public static void main(String[] args) throws  Exception {
   
        // 加载驱动(使用Driver来创建该类的对象，放入到内存中)   关系： 非常亲密    高耦合
        // 降低耦合度     低耦合  解耦   ： 使用反射机制来创建对象，并维护类与类之间的关系
        //DriverManager.registerDriver(new Driver());  // 硬编码
        Class.forName("com.mysql.jdbc.Driver");

        // 建立连接
        Connection connection = DriverManager.getConnection("jdbc:mysql:///duobiao", "root", "root");
        System.out.println( connection);
    }
}

工厂模式模仿spring的IOC

定义一个dao层并实现改层的方法(save() update() ),编写一个service层来调用dao层中的方法来实现功能.

UserDao.java

public interface UserDao {
   

    public void save();

    public void update();
    
}

UserDaoImpl.java

public class UserDaoImpl implements UserDao {
   
    @Override
    public void save() {
   
        System.out.println("----------添加数据（Mysql）----------");
    }

    @Override
    public void update() {
   
        System.out.println("=============修改数据（Mysql）========");
    }
}

UserOracleDaoIml.java

public class UserOracleDaoImpl implements UserDao {
   
    @Override
    public void save() {
   
        System.out.println("------添加数据(oracle)--------");
    }

    @Override
    public void update() {
   
        System.out.println("+++修改数据(oracle)+++");
    }
}

UserServer.java

public class UserService {
   
    // 使用servie中的业务方法来调用dao中的方法来使用
    //UserDao userDao = new UserDaoImpl();
    UserDao userDao = new UserOracleDaoImpl();
    // 分析缺点：  userServer和UserDao之间的耦合性较高    userDao不存在    硬编码方式
    //   解决 :  降低耦合  解耦   :   反射机制（BeanFactory）

    public void insert(){
   
        userDao.save();
    }

    public void update(){
   
        userDao.update();
    }
}

UserUI.java

public class UserUI {
   

    public static void main(String[] args) {
   
        UserService userService = new UserService();

        userService.insert();

        userService.update();
    }
}

分析

​ 再UserServie中会发现，如果想要执行dao中的方法实现添加，那么必须使用 new 来创建userDao对象，如果连接不同的数据库，则 new 后的类也要随之改变，这种为***硬编码*方式,该方式不利于代码更改，类与类之间的耦合性较高，不符合"高内聚，低耦合"**的编程思想。

解决

​ 可以使用反射机制与工厂模式来创建一个工厂类，通过配置文件形式来搭建类与类之间的关系.使用反射机制的原来来代替原有的new来创建对象的过程。

BeanFactory.java

public class BeanFactory {
   

    private static Properties properties = new Properties();
    static{
   
        InputStream rs = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
   
            properties.load(rs);
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }

    // 定义一个静态方法，来使用java的反射机制创建对象
    public static Object getInstance(String key){
   
        Object object = null;
        try {
   
            Class<?> ac = Class.forName(properties.getProperty(key));
            object = ac.newInstance();
        } catch (Exception e){
   
            e.printStackTrace();
        }
        return object;
    }
}

bean.properties

# key = value
userDao=cn.hd.dao.impl.UserOracleDaoImpl
userService=cn.hd.service.UserService

则userSercie中的对象创建就变为了以beanFactory的模式创建了

 //   解决 :  降低耦合  解耦   :   反射机制（BeanFactory）
 UserDao userDao = (UserDao) BeanFactory.getInstance("userDao");

UserUI中的创建userService的对象创建也变为了beanFactory的模式创建了

 public static void main(String[] args) {
   
        //UserService userService = new UserService();
        // 改变后
        UserService userService = (UserService) BeanFactory.getInstance("userService");
        userService.insert();
        userService.update();
    }

总结

​ 使用工厂模式和反射机制来实现以配置文件的形式创建对象的模式，可以释放类与类之间的耦合度，实现解耦

缺点

​ 类与类之间的关系还不能完全解耦，那么我们就可以学习使用spring框架来实现完全解耦了。

spring入门案例

实现步骤：

​ 1，再pom.xml文件中配置spring的核心jar包坐标