Spring框架第一天(搭建项目)

Spring框架

1.简介

1.1 Spring是什么

• 一个开源的框架，是JavaEE开源框架

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

• 控制翻转和依赖注入

• 框架的优势

• 

• 

• 体系结构

• 

2. 补充:Java的三层结构

• 业务层（逻辑层、service层）

  • 采用事务脚本模式。将一个业务中所有的操作封装成一个方法，同时保证方法中所有的数据库更新操作，即保证同时成功或同时失败。避免部分成功部分失败引起的数据混乱操作。

• 表现层（JSP）

  • 采用MVC模式
  • M称为模型，也就是实体类。用于数据的封装和数据的传输。
  • V为视图，也就是GUI组件，用于数据的展示（现在通常为HTML+CSS）。
  • C为控制，也就是事件，用于流程的控制。

• 持久层（DA0）

  • 采用DAO模式，建立实体类和数据库表映射（ORM映射）。也就是哪个类对应哪个表，哪个属性对应哪个列。持久层的目的就是，完成对象数据和关系数据的转换

• 图示

  

• SSM框架

  • 业务层——Spring
  • 表现层——SpringMVC
  • 持久层——MyBatis

3. 补充：高内聚低耦合

• 参考文献：https://blog.csdn.net/u012862227/article/details/47296899

• 参考文献：https://zhuanlan.zhihu.com/p/265143336

• 什么是高内聚低耦合

  • 每个模块之间相互联系的紧密程度，模块之间联系越紧密，则耦合性越高，模块的独立性就越差！反之同理；
  • 一个模块中各个元素之间的联系的紧密程度，如果各个元素（语句、程序段）之间的联系程度越高，则内聚性越高，即‘高内聚’

• 例如

  • 如: 一个项目中有20个方法调用良好，但是要修改了其中一个，另外的19个都要进行修改，这就是高耦合！独立性太差！

    现在的软件结构设计，都会要求“高内聚，低耦合”，来保证软件的高质量！mark！

4.补充CRUD是什么

• CRUD是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。主要被用在描述软件系统中DataBase或者持久层的基本操作功能。

• CRUD说的就是增查改删

  • C：Create 增加对应CREATE TBL ...； ADD TBL IN (...) VALUES (...)
  • R：Retrieve查询SELECT * from TBL
  • U：Update修改UPDATE TBL ..SET ...
  • D：Delete删除 DELETE FROM TBL WHERE ....

5.搭建Spring项目

5.1 快速搭建（基于Maven的方式）

• 创建项目

  

  

  修改Maven的指定的路径；

  

  如果没有resource文件则手动添加；

  

5.2 配置pom.xml文件中的包坐标

• <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>5.3.9</version>
  </dependency>
  

5.3 创建接口和接口实现类

• 

  //接口
  package com.one.dao;
  
  public interface UserDao {
      public void save();
  }
  
  //实现类
  package com.one.dao.impl;
  
  import com.one.dao.UserDao;
  
  public class UserDaoImpl implements UserDao {
      @Override
      public void save() {
          System.out.println("save() runing.....");
      }
  }
  
  

5.4 创建并编写配置文件

• 在resource文件夹下创建Spring-config类型的配置文件；名称一般叫做applicationContext.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="UserDao" class="com.one.dao.impl.UserDaoImpl"></bean>   只有这一行不是自动生成，是自己编写的；后期随着功能的增加进行编写
  </beans>
  

5.5 编写启动文件

• 创建启动类包含main方法的类；

• 

  package com.one.demo;
  
  import com.one.dao.UserDao;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class UserDaoDemo {
      public static void main(String[] args) {
          ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
          //Object userDao = app.getBean("UserDao");//多态写法需要进行强类型转换
          UserDao userDao =(UserDao) app.getBean("UserDao");//多态写法需要进行强类型转换
          userDao.save();
      }
  }
  
  

  
  
  执行成功；

4、配置文件详解

4.1Bean标签基本配置

• <bean id="UserDao" class="com.one.dao.impl.UserDaoImpl"></bean>
  

• 编写测试代码

  package com.one.test;
  
  import com.one.dao.UserDao;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class SpringTest {
      @Test
      public void test1(){
          ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
          //Object userDao = app.getBean("UserDao");//多态写法需要进行强类型转换
          UserDao userDao =(UserDao) app.getBean("UserDao");//多态写法需要进行强类型转换
          UserDao userDao1 =(UserDao) app.getBean("UserDao");//多态写法需要进行强类型转换
          userDao.save();
          System.out.println(userDao1);
          System.out.println(userDao);
      }
  }
  

• 用于配置对象交由Spring 来创建。

• 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

  • id：Bean实例在Spring容器中的唯一标识
  • class：Bean的全限定名称

4.2 Bean标签范围配置

• 

• 当scope的取值为singleton时

  • Bean的实例化个数：1个
    
    Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
    
    Bean的生命周期：
    
     对象创建：当应用加载，创建容器时，对象就被创建了
    
     对象运行：只要容器在，对象一直活着
    
     对象销毁：当应用卸载，销毁容器时，对象就被销毁了

• <bean id="UserDao" class="com.one.dao.impl.UserDaoImpl" scope="singleton"></bean>
  

• 

  地址值相同只有一个对象的实例；

• 当scope的取值为prototype时

  • Bean的实例化个数：多个
  • Bean的实例化时机：当调用getBean()方法时实例化Bean
    
     对象创建：当使用对象时，创建新的对象实例
    
     对象运行：只要对象在使用中，就一直活着
    
     对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

• <bean id="UserDao" class="com.one.dao.impl.UserDaoImpl" scope="prototype"></bean>
  

• 

4.3 Bean生命周期配置

• init-method：指定类中的初始化方法名称

• destroy-method：指定类中销毁方法名称

• <bean id="UserDao" class="com.one.dao.impl.UserDaoImpl" scope="prototype"></bean>
  

• package com.one.test;
  
  import com.one.dao.UserDao;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class SpringTest {
      @Test
      public void test1(){
          ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
          //Object userDao = app.getBean("UserDao");//多态写法需要进行强类型转换
          UserDao userDao =(UserDao) app.getBean("UserDao");//多态写法需要进行强类型转换
          UserDao userDao1 =(UserDao) app.getBean("UserDao");//多态写法需要进行强类型转换
          userDao.save();
          System.out.println(userDao1);
          System.out.println(userDao);
          app.close();
      }
  }
  
  

4.4 Bean实例化三种方式

• 无参构造方法实例化
• 工厂静态方法实例化
• 工厂实例方法实例化

1） 使用无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

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

补充：工厂模式

• 参考文档：https://www.cnblogs.com/JuanF/p/9275833.html

• 设计原则

  • 开闭原则：对扩展开放，对修改关闭
  • 里氏代换原则：只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被覆用。而衍生类也能够在基类的基础上增加新的行为
  • 依赖倒转原则：开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体
  • 接口隔离原则：使用多个隔离的接口来降低耦合度
  • 迪米特法原则：最少知道原则。一个实体应该尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立
  • 合成复用原则：尽量使用合成/聚合的方式，而不是使用继承。继承实际上破环了类的封装性，超类的方法可能会被子类修改。

• 工厂模式

  

• 上述模式下，所有的鼠标都在同一个MouseFactory工厂下生产，有一个统一的create静态方法。在使用工厂时，不需要对工厂进行实例化，只需要调用该静态方法便可得到相应的产品。

  但如果用户需要添加新一类的产品，例如有一项华硕鼠标，工厂要生产该产品则需要改create函数，这有悖于设计原则的开闭原则。

• 

• 在该模式下，不同品牌的产品交由不同的工厂来生产，有一个统一的工厂接口，生产该产品的工厂都要实现该接口。

  生产哪种产品不再由参数决定，而是在创建工厂时让工厂来决定，例如惠普的工厂只会生产惠普的鼠标，而戴尔的工厂只会生产戴尔的鼠标。

• 更多详细内容查看参考文档；