筝弈
筝弈

黑马程序员2022新版SSM框架Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus企业实用开发技术——万字学习笔记：Spring+SpringMVC篇

学习目标：

提示：这里可以添加学习目标

例如：

  • 一周掌握 Java 入门知识

学习内容：

提示：养成自学好习惯和攻克难关能力

学习Spring+SpringMVC

学习时间：

提示：找了份单休的工作边打工边学习，花了一个半月的时间学到这里

例如：

  • 周二至周五早上 7 点-早上 9点， 晚上 10 点-晚上 1 点
  • 周六晚上 10 点-晚上 12 点
  • 周日下午 10 点-下午 12 点
  • 周一早上 10 点-下午1点，下午2点到晚上8点

学习产出：

提示：代码行数不记得

例如：

  • 技术笔记1.6万字的笔记一篇

Spring

为什么要学Spring？

1.专业角度：

  • 简化开发，降低企业级开发的复杂性

  • 框架整合，高效整合其他计算，提高企业级应用开发与运行效率

2.学什么？

  • 简化开发
    • IOC
    • AOP
      • 事务处理
  • 框架整合
    • MyBatis
    • MyBatis-plus
    • Struts
    • Struts2
    • Hibernate
    • …

Spring Framework系统架构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-onTECLoY-1669819301997)(https://ts1.cn.mm.bing.net/th/id/R-C.40d21cdfc59cb8a652614cc7cfe0fd87?rik=4Bx8Us0bCDQ0FQ&riu=http%3a%2f%2fstatic.oschina.net%2fuploads%2fspace%2f2014%2f1231%2f111732_x0O8_1249631.png&ehk=nRnxwQgIJeO4XeIMAlfz2p7qAZwAyNSQ8Y%2fJoPmvIeI%3d&risl=&pid=ImgRaw&r=0)]

  • Core Container：核心容器
  • Aspects：AOP思想实现
  • AOP：面向切面
  • Data Integration：数据集成
  • Data Access：数据访问
  • Test：单元测试与集成测试

大纲

第一部分：核心容器

  • 核心概念（IoC/DI）
  • 容器基本操作

第二部分：整合

  • 整合数据层技术MyBatis

第三部分：AOP

  • 核心概念
  • AOP基础操作
  • AOP实用开发

第四部分：事务

  • 事务开发

第五部分：家族

  • SpringMVC
  • SpringBoot
  • SPringCloud

核心容器

1.核心概念

  • IoC（Inversion of Control）控制反转
    • 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转
  • Spring技术对IoC思想进行了实现
    • 由Spring提供了一个容器，称为IoC容器，来充当IoC思想中的"外部"
    • IoC容器负责对象的创建，初始化等一系列，被创建或被管理的对象在IoC容器中统称为Bean
  • DI（Dependency Injection）依赖注入
    • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
  • 目标：充分解耦
    • 使用IoC容器管理bean（IoC）
    • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终效果
    • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

2.IoC入门案例

  1. 管理什么？（Service与Dao）

  2. 如何将被管理的对象告知IoC容器？（配置）【将bean注册到application.xml里面】【通过xml管理IoC容器】

  3. 被管理的对象交给IoC容器，如何获取到IoC容器？（接口）

    一般，通过ApplicationContext接口中的实现类ClassPathXmlApplicationContext()

  4. IoC容器得到后，如何从容器中获取bean？（接口方法）

    通过ApplicationContext接口中的getBean方法

  5. 使用Spring导入哪些坐标？（pom.xml，在depencies里面导入坐标）

    
<dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.10.RELEASEversion>
dependency>


//步骤2：定义Spring管理的类（接口）
public interface BookService{
	void save();
}
//实现接口
public class BookServiceImpl implements BookService{
	private BookDao bookDao = new BookDaoImpl();
	public void save(){
		bookDao.save();
	}
}



<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="bookDao" class="com.hcx.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.hcx.service.impl.BookServiceImpl"/>

3.DI入门案例

  1. 基于IoC管理bean
  2. Service中使用new形式创建的Dao对象是否保留？(否)
  3. Service中需要的Dao对象如何进入到Service中？【使用依赖注入】(提供方法)
  4. Service与Dao间的关系如何描述？（配置）【一个业务层可以控制很多数据层】
//步骤1：将业务层中的new的DAO对象删除，使用set方法实现

public class BookServiceImpl implements BookService{
	private BookDao;
	public void save(){
		bookDao.save();
	}
    //提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
        System.out.println("提供了对应的set方法");
    } 
}


<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.hcx.service.impl.BookServiceImpl">
	
    <property name="bookDao" ref="bookDao"/>
bean>

4.Bean的配置

Bean的别名

在application.xml起别名,或取多个别名，【用空格，或者逗号，或者分号分隔开来】

ref属性既可以引用id也可以引用name

<bean id="bookDao" name="dao dao2" class="com.hcx.dao.impl.BookDaoImpl"/>
<bean id="bookService" name="service" class="com.hcx.service.impl.BookServiceImpl">
	
    <property name="bookDao" ref="dao"/>
bean>

public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService= (BookService) context.getBean("service");
        bookService.save();
    }
//把getBean方法里的名称换为bean的别名也是可以的

注意：获取bean无论是通过id还是name获取，如果无法获取到，将抛出NoSuchBeanDefinitionException

Bean的作用范围【单例或非单例】

在application.xml中配置bean的作用范围

属性：scope

所属：bean标签

功能：定义bean的作用范围：

  • singleton：单例（默认）
  • prototype：非单例

范例：

<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl" scope="prototype"/>
  • 为什么bean默认的是单例的?

​ —便于管理复用对象，提高效率

  • 适合交给容器进行管理的bean

    • 封装实体的域对象（有状态的）

Bean的实例化方法

  • Bean本质上就是对象，创建bean使用构造方法完成
方法一：构造方法实现Bean
//首先在application中注册bean
//其次在实现类中实现构造方法实例化实现类
private BookDaoImpl(){
	System.out.println("Book is constructor is running ...");
}
//无论是使用private还是public都能访问到构造方法，利用到了反射
//无参构造方法是默认实现


<bean id="bookkDao" class="com.hcx.dao.impl.BookDaoImpl"/>
方法二：使用静态工厂
//新建一个静态工厂
public class OrderDaoFactory{
public static OrderDao getOrderDao(){
    return new OrderDaoImpl();
	}
}
//实例化对象时getBean()方法调用静态工厂实例化对象

<bean id="orderDao" class="com.hcx.factory.OrderDaoFactory" factory-method="getOrderDao"/>
方法三：实例工厂
public class AppForInstanceUser{
	public static void main(String[] args){
        //创建实例静态工厂对象
        UserDaoFactory userDaoFactroy = new UserDaoFactory();
        //通过实例工厂对象创建对象
        User userDao = userDaoFactory.getUserDao();
        userDao.save();
    }
}

public class UserDaoFactory{
    public UserDao getUserDao(){
        retrun new UserDaoImpl();
    }
}

<bean id="userFactory" class="com.hcx.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
方式四:FactoryBean
public class UserDaoFactoryBean implements FactoryBean<UserDao>{
    public UserDao getObject() throws Expection{
        return new UserDaoImpl();
    }
    public Class<?> getObjectType(){
        return UserDao.class;
    }
}

<bean id="userDao" class="com.hcx.factory.UserDaoFactoryBean"/>

Bean的生命周期

  • 生命周期:从创建到消亡的完整过程
  • bean生命周期:bean从创建到销毁的整体过程
  • bean生命周期控制:在bean创建后到销毁前做一些事情
public void init(){
    System.out.print("Bean初始化操作");
}
public void destory(){
    System.out.print("Bean销毁操作");
}

<bean id="bookDao" class="com.hcx.impl.BookDaoImpl" init-method="init" destory-method="destory"/>

//无法调用销毁方式原因，JVM直接退出，未执行关闭ClassPathXmlApplicationContext对象
eg:
// 不用 ApplicationContext接口下ClassPathXmlApplication实现类型下的close()方法 ，还可以使用使用ApplicationContext下的实现类AnnotationConfigApplicationContext()实现下的close()方法
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao bookDao =(BookDao) context.getBean("bookDao");
//暴力方法
context.close();
//灵巧方法
context.registerShutdownHook();

//bean生命周期，标准实现方式，实现InitializingBean, DisposableBean两个接口中的方法
eg:
public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    //    删除业务层中使用new的方式创建dao对象
//    private BookDao bookDao = new BookDaoImpl();
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

    //提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
        System.out.println("提供了对应的set方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("service destory");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

总结

bean生命周期

  • 初始化容器

    1. 创建对象（内存分配）
    2. 执行构造方法
    3. 执行属性注入（set操作）
    4. 执行bean初始化方法

  • 使用bean

    1. 执行业务操作

  • 关闭/销毁容器

    1. 执行bean销毁方法

    bean销毁时机

    • 容器关闭前触发bean的销毁

    • 关闭容器方式

      • 手工关闭容器

        ConfigurableApplicationContext接口close()操作

      • 注册关闭钩子，在虚拟机退出前线关闭容器再退出虚拟机

        ConfigurableApplicationContext接口registerShutdownHook()操作

    控制bean生命周期的两种方法

  • 配置

    • init-method
    • destory-method

  • 接口

    • InitializingBean

    • DisposableBean

依赖注入方式

  • 思考：向一个类中传递数据的方式有几种？
    • 普通方法（set方法）
    • 构造方法
  • 思考：依赖注入描述了在容器中建立bean与bean之间依赖关系的过程，如果bean运行需要的是数字或字符串呢？
    • 引用类型
    • 简单类型（基本数据类型与String）
  • 依赖注入方式
    • setter注入
      • 简单类型
      • 引用类型
    • 构造器注入
      • 简单类型
      • 引用类型

Setter注入——引用类型

  • 在bean中定义引用类型属性并提供可访问的set方法

    public class BookServiceImpl implements BookService(
	private BookDao bookDao;
    public void setBookDao(BookDao bookDao){
        this.bookDao = bookDao;
    }
)

  • 配置中使用property标签****value属性注入引用类型对象

    <bean id="bookService" class="com.hcx.service.impl.BookServiceImpl">
	<property name="bookDao" ref="bookDao"/>
bean>
<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl"/>

Setter注入——简单类型

  • 在bean中定义简单类型属性并提供可访问的set方法
public class BookDaoImpl implements BookDao(
	private int connectionNum;
	private String databaseName;
	public void setConnectionNum(int connectionNum){
        this.connectionNum=connectionNum;
    }
    public void setDatabaseName(String databaseName){
        this.databaseName=datanaseName;
    }
)
  • 配置中使用property标签****value属性注入基本类型对象
<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl">
	<property name="connectionNum" value="100"/>
    <property name="databaseName" value="MySql"/>
bean>

构造器注入——引用类型

  • 在bean中定义引用类型属性并提供可访问的构造方法
public class BookServiceImpl implements BookService(
	private BookDao bookDoa;
    public BookServiceImpl(BookDao bookDao){
        this.bookDao = bookDao;
    }
)
  • 配置中使用constructor-arg标签ref属性注入引用类型对象
<bean id="bookService" class="com.hcx.service.impl.BookServiceImpl">
	<constructor-arg name="bookDao" ref="bookDao"/>
bean>
<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl"/>

构造器注入——简单类型

  • 在bean中定义引用类型属性并提供可访问的set方法
public class BookDaoImpl implements BookDao{
	private int connectionNumber;
    public BookDaoImpl(int connectionNumber){
   		this.connectionNumber = connectionNumber;
    }
}
  • 在配置中使用constructor-arg标签value属性注入简单数据类型
<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl">
	<constructor-arg name="connectionNumber" value="10"/>
bean>

参数设置

  • 配置中使用constructor-arg标签type属性设置按形参类型注入
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
	<constructor-arg type="int" value="10"/>
	<constructor-arg type="java.lang.String" value="mysql"/> 
bean>
  • 配置中使用constructor-arg标签index属性设置按形参位置注入
<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl">
	<constructor-arg index="0" value="10"/>
	<constructor-arg index="1" value="MYSQL"/>
bean>

依赖注入方式选择

  1. 强制依赖使用构造器进行，使用setter注入有概率步进行注入导致null对象出现
  2. 可选依赖使用setter注入进行，灵活性能强
  3. Spring框架倡导使用构造器，第三方框架内大多数采用构造器注入的形式进行数据初始化，相对严谨
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选项依赖的注入
  5. 实际开发过程中还要更卷实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
  6. 自己开发的模块推荐使用setter注入

依赖自动装配

  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称之为自动装配

  • 自动装配方式

    • 按类型（常用）
    • 按名称
    • 按构造方法
    • 不启用自动装配

  • 配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.hcx.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.hcx.service.impl.BookServiceImpl" autowire="byType"/>
  • 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  • 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  • 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名和配置耦合，不推荐使用
  • 自动装配优先级低于setter注入和构造器注入，同时出现时自动装配失效

集合注入

数据类型：

数组

<property name="array">
	<array>
		<value>100value>
		<value>200value>
		<value>300value>
	array>
property>

List

<property name="list">
            <list>
                <value>加油value>
                <value>每天value>
                <value>学习value>
            list>
property>

Set

<property name="set">
            <set>
                <value>好好value>
                <value>工作value>
                <value>跑路value>
            set>
property>

Map

<property name="map">
            <map>
                <entry key="country" value="china">entry>
                <entry key="city" value="成都">entry>
                <entry key="province" value="四川">entry>
            map>
property>

Properties

<property name="properties">
            <props>
                <prop key="country">中国prop>
                <prop key="city">南昌prop>
                <prop key="province">江西prop>
            props>
property>

案例：数据源对象管理

  • 导入druid坐标

    <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.10version>
dependency>

  • 配置数据源对象作为spring管理的bean


    <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/message"/>
        <property name="username" value="root"/>
        <property name="password" value="505489"/>
    bean>
  • 导入c3p0坐标和mysql连接坐标
 <dependency>
            <groupId>c3p0groupId>
            <artifactId>c3p0artifactId>
            <version>0.9.1.2version>
 dependency>
 <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.6version>
 dependency>
  • 配置数据源对象作为spring管理的bean
  • 加载properties文件
    1. 首先开启命名空间
<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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
">
beans>

​ 2.使用context空间加载properties文件

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

​ 3.使用属性占位符${}读取properties文件中的属性

<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>

加载properties文件

  • 不加载系统属性
  • 加载多个properties文件
<context:property-placeholder location="jdbc.properties,msg.properties"/>
  • 加载所有properties文件
<context:property-placeholder location="*.properties"/>
  • 加载properties文件标准格式
<context:property-placeholder location="classpath:*.properties"/>
  • 从路径或jar包中搜索properties文件
<context:property-placeholder location="classpath*:*.properties"/>

容器

容器创建(顶级父类BeanFactory接口)

  • 方式一：路径加载配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  • 方式二：文件路径加载配置文件
ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");
  • 方式三：读取web下的资源文件
XmlWebApplicationContext ctx = new XmlWebApplicationContext();
  • 加载多个配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml","bean2.xml");

获取bean

  • 方式一：使用bean名称获取
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  • 方式二：使用bean名称获取并指定类型
BookDao bookDao = ctx.getBean("bookDao",BookDao.class);
  • 方式三：使用bean类型获取
BookDao bookDao = ctx.getBean(BookDao.class);

容器层次结构

总览 BeanFactory 体系，按照接口的抽象层次，大体可以分层四层：

  • 第一层：BeanFactory；
  • 第二层：HierarchicalBeanFactory，ListableBeanFactory，AutowireCapableBeanFactory；
  • 第三层：ConfigurableBeanFactory，此外还有一个关联性较强SingletonBeanRegistry；
  • 第四层：ConfigurableListableBeanFactory；

BeanFactory初始化

  • 类路径加载配置文件
Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao =  bf.getBean("bookDao",BookDao.class);
bookDao.save();

注意：BeanFactory创建完毕后，所有的bean均为延时加载

延时加载好处：当为了追求传输效率就会需要什么就再去创建什么时,就会体现出延迟加载的好处，有一个缓冲时间。

核心容器总结

容器相关

  • BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延时加载

  • ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载

  • ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能

  • ApplicationContext接口常用初始化类

    • ClassPathXmlApplicationContext
    • FileSystemXmlApplicationContext

bean相关

<bean
	id="bookDao"														 bean的Id
	name="dao bookDaoImpl daoImpl"										   bean的别名
	class="com.itheima.dao.impl.BookDaoImpl"							    bean的类型，静态工厂，FactoryBean类
	scope="singleton" 													  控制bean的实例数量
	init-method="init"													  生命周期初始化方法
	destory-method="destory"											   生命周期销毁方法
	autowire="byType"													  自动装配类型
	factory-method="getInstance"										   bean工厂方法，应用于静态工厂或实例工厂
	factory-bean="com.itheima.factory.BookDaoFactory"						 实例工厂bean
	lazy-init="true"													  控制bean延时加载
	/>

依赖注入

<bean id="bookSerbice" class="com.hcx.impl.BookServiceImpl">
	<constructor-arg name="bookDao" ref="bookDao"/>							构造器注入引用类型
    <constructor-arg name="userDao" ref="userDao"/>							 
    <constructor-arg name="msg" value="WARN"/>								构造器注入简单类型	
    <constructor-arg type="java.lang.String" index="3" value="WARN"/> 		  类型匹配与索引匹配
    <property name="bookDao" ref="bookDao"/>								setter注入引用类型
    <property name="userDao" ref="userDao"/>								
    <property name="msg" value="WARN"/>										setter注入简单类型
    <property name="names">												   list集合
    	<list>
        	<value>itcastvalue>										   集合注入简单类型
            <ref bean="dataSource"/>									    集合注入引用类型
        list>
    property>
bean>

注解开发

注解开发定义bean

  • 使用@Component定义bean
@Component("bookDao")
public class BookDaoImpl implements BookDao{
}
@Component
public class BookServiceImpl implements BookService{
}
  • 核心配置文件中通过组件扫描加载bean
<context:component-scan base-package="com.hcx"/>
  • Spring提供@Component注解的三个衍生注解
    • @Controller：用于表现层bean定义
    • @Service：用于业务层bean定义
    • @Repository：用于数据层bean定义
@Repository("bookDao")
public class BookDaoImpl implements BookDao{
}
@Service
public class BookServiceImpl implements BookService{
}

Spring 3.0 纯注解开发

  • Spring 3.0 升级了纯注解开发模式，使用了Java类代替配置文件，开启了Spring快速开发赛道
  • Java类代替Spring核心配置文件，

<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.springframework.org/schema/beans/spring-beans.xsd">
	   <context:component-scan base-package="com.hcx"/>
beans>

被

@Configuration
@ComponentScan("com.hcx")
public class SpringConfig{
}

代替

  • @Configuration注解用于设定当前类为配置类
  • @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
@ComponentScan({"com.hcx.service","com.hcx.dao"})
  • 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
//加载配置文件初始化容器（xml版）
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

总结

  1. 定义bean

    • @Component

      • @Controller

      • @Service

      • @Repository

  2. 纯注解开发

    • @Configuration
    • @ComponentScan
    • AnnotationConfigApplicationContext

注解开发bean管理

  1. bean的作用范围
    • @Scope
  2. bean的生命周期
    • @PostConstruct
    • @PreDestroy

注解开发依赖注入

自动装配

引用类型注入
  • 使用@Autowired注解开启自动装配模式（按类型）
@Servcie
public class BookServiceImpl implements BookService{
	@Autowired
	private BookDao bookDao;
	public void setBookDao(BookDao bookDao){
	this.bookDao=bookDao;
	}
	public void save(){
	System.out.print("book service save ...");
	bookDao.save();
	}
}

  • 注意：自动装配基于反射设计创建对象并暴力反射对应属性初始化数据，因此无需提供setter()方法

  • 注意：自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法

  • 使用@Qualifier注解开启指定名称装配bean

@Service 
public class BookServiceImpl implements BookService{
	@Autowired
	@Qualifier("bookDao")
	private BookDao bookDAO;
}
  • 注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用
简单数据类型注入

在定义的数据类型上放使用@Value("值")

@Value("学习")
private String action;

加载外部properties文件

  • 在SpringConfig类下，使用@PropertySource注解加载properties文件
@Configuration
@ComponentScan("com.hcx")
@uPropertySource("classpath:jdbc.properties")
public class SpringConfig{}
  • 在给属性注入值时
@Value("${外部文件中定义的属性名}")
private String value;
  • 注意：路径仅支持单一文件配置，多文件请使用数组格式配置，不允许使用通配符*
总结回顾
  1. 自动装配
    • @Autowired：自动装配暴力映射
    • @Qualifier：指定名称注入
    • @value：注入简单类型
  2. 读取properties文件
    • @PropertySource：在SpringConfig里读取外部文件

第三方bean管理

第三方bean配置
  • 使用@Bean配置第三方bean
@Configuration
public class SpringConfig{
	@Bean
	public DataSource dataSource(){
    DruidDataSource ds = new DruidDataSource();
	ds.setDriverClassName("com.mysql.jdbc.Driver");
	ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
	ds.setUsername("root");
	ds.setPassword("root");
	return ds;
	}
}
//不推荐
  • 将独立的配置类加入核心配置
  • 方式一：导入式
public class JdbcConfig{
	@Bean
	public DataSource dataSource(){
	DruidDataSource ds = new DruidDataSource();
	//相关配置
	return ds;
	}
}
  • 使用@Import注解手动加入配置类到核心配置，此注解只能添加一次，多个数据请用数组格式
@Configuration
@Import(JdbcConfig.class)
public class SpringConfig{
}
第三方bean依赖注入
  • 简单类型依赖注入
public class JdbcConfig{
	@Value("com.mysql.jdbc.Driver")
	private String dirver;
	@Value("jdbc:mysql://localhost:3306/spring_db")
	private String url;
	@Value("root")
	private String userName;
	@Value("505489")
	private String password;
	@Bean
	public DataSource dataSource(){
		DruidDataSource ds = new DruidDatSource();
		ds.setDriverClassName(driver);
		ds.setUrl(url);
		ds.setUserName(userName);
		ds.setPassword(password);
		return ds;
	}
}
  • 引用类型依赖注入
@Bean
public DataSource dataSource(BookService bookService){
	Sytstem.out.print(bookService);
	DruidDataSource ds = new DruidDataSource();
	//属性设置
	return ds;
}
  • 引用类型注入只需要为bean定义方法设置形参即可，容器会更卷类型自动装配对象

总结

第三方Bean总结
  1. 第三方bean管理
    • @Bean
  2. 第三方依赖注入
    • 引用类型：方法形参
    • 简单类型：成员变量
XML配置对比注解配置
功能 XML配置 注解
定义bean bean标签：id属性 class属性 @ComponentScan @Component：@Controller @Service @Repository
设置依赖注入 setter注入（set方法）：引用/简单 构造器注入（构造方法）：引用/简单 自动装配 @Autowired:@Qualifier @Value
配置第三方bean bean标签 静态工厂,实例工厂，FactoryBean @Bean
作用范围 scope属性 @Scope
生命周期 标准接口：init-method destory-method @PostConstryctor @ProDestory

Spring整合MyBatis

xml方式实现
  • MyBatis程序核心对象分析
//1.创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilde();
//2.加载SqlMapConfig.xml配置文件
InpiyStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
//3.创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
/*初始化SqlSessionFactroy*/
//4.获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
//5.执行SqlSession对象执行查询，获取结果User
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
/*获取实现*/
Account ac = accountDao.findById(2);
System.out.printIn(ac);
/*获取数据层接口*/
//6.释放资源
sqlSession.close();
/*关闭连接*/
  • 整合MyBatis
<configuration>
    
    <properties resource="jdbc.properties">properties>
    
    <typeAliases>
        <package name="com.itheima.domain"/>
    typeAliases>
    
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC">			               <dataSource type="POOLED">
            	<property name="driver" value="${jdbc.driver}">property>
                <property name="url" value="${jdbc.url}">property>
                <property name="username" value="${jdbc.username}">property>
                <property name="password" value="${jdbc.password}">property>
            dataSource>
            transactionManager>
        environment>
    environments>
    
    <mappers>
    	<package name="com.itheima.do">package>
    mappers>
configuration>
注解方式实现
  • 注册SqlSessionFactoryBean类，并配置数据库
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
	SqlSessionFactryBean ssfb = new SqlSessionFactoryBean();
    ssfb.setTypeAliasePackage("com.hcx.pojo");
    ssfb.setDataSource(dataSource);
    return ssfb;
}
  • 配置映射包
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
	MapperScannerConfigurer msc = new MapperScannerConfigurer();
	msc.setBasePackage("com.hcx.dao");
	return msc;
}
整合JUnit
测试接口(一般测业务层，很少测数据层)
  • 使用Spring整合Junit专业类加载器
@RunWith(SpringJUnit4ClassRunner.class)
@ConetextConfiguration(classes = SpringConfig.class)
public Class BookServiceTest{
	@Autowired
	private BookService bookService;
	
	@Test
	public void testSave(){
		bookservice.save();
	}
}

AOP

AOP简介

  • AOP（Aspect Oriented Programming）面向切面编程，是一种编程范式，指导开发者如何组织程序结构
    • OOP（Object Oriented Programming）面向对象编程
  • 作用：在步惊动原始设计的基础上进行功能增强，追加功能
  • Spring理念：无侵入式

AOP核心概念

  • 连接点（JoinPoint）：程序执行过程中的任意位置，粒度为执行方法，抛出异常，设置变量等
    • 在SpringAOP中，理解为方法的执行
  • 切入点（Pointcut）：匹配连接点的式子
    • 在SpringAop中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
      • 一个具体方法：com.hcx.dao包下的BookDao接口中的无形参返回值的save方法
      • 匹配多个方法，所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
  • 通知（Advice）：在切入点处执行的操作，也就是共性功能
    • 在Spring中，功能最终以方法的形式呈现
  • 通知类：定义通知的类
  • 切面（Aspect）：描述通知与切入点的对应关系

AOP入门案例（注解版）

  1. 导入aop相关坐标
<dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.9.4version>
dependency>

说明：Spring-context坐标依赖spring-aop坐标

2.定义dao接口与实现类

public interface BookDao{
	public void save();
	public void update();
}

@Repository
public class BookDaoImpl implements BookDao{
	public void save(){
		System.out.println(System.currentTimeMills());
		System.out.println("book dao save...");
	}
	
	public void update(){
		System.out.println("book dao update...");
	}
}

3.定义通知类，制作通知

public class MyAdvice{
	public void before(){
	System.out.println(System.currentTimeMills());
	}
}

4.定义切入点

public class MyAdvice{
	@Pointcut("execution(void com.hcx.dao.BookDao.update())")
	private void pt(){}
}

说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

5.绑定切入点与通知关系，并指定通知添加到原始连接点的具有执行位置

public class MyAdvice{
	@Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void before(){
        System.out.println(System.currenTimeMillis());
    }
}

6.定义通知类受Spring容器管理，并定义当前类为切面类

@Componet
@Aspect
public class MyAdvice{
	@Pointcut("execution(void com.hcx.dao.BookDao.update())")
	private void pt(){}
	@Before("pt()")
	public void before(){
		System.out.println(System.currentTimeMillis());
	}
}

7.开启Spring对AOP注解驱动支持

@Configuration
@ComponetScan("com.hcx")
@EnableAspectAutoProxy
public class SpringConfig{
}

AOP工作流程

1.Spring容器启动

2.实现所有切面配置中的切入点

@Component
@Aspect
public class MyAdvice{
@Pointcut("excution(void com.hcx.dao.BookDao.save())")
private void ptx(){}

@Pointcut("excution(void com.hcx.dao.BookDao.update())")
private void pt(){}

@Before("pt()")
public void method(){
	System.out.println(System.currentTimeMillis());
	}
}

3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

  • 匹配失败，创建对象
  • 匹配成功，创建原始对象（目标对象）的代理对象

4.获取bean执行方法

  • 获取bean，调用方法并执行，完成
  • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP核心概念

  • 目标对象（Target）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
  • 代理（Proxy）：目标对象无法直接工作，需要对其进行功能会填，通过原始对象的代理对象实现
  • SpringAOP本质：代理模式

AOP切入表达式

  • 切入点：要进行增强的方法
  • 切入点表达式：要进行增强方法的描述方式
public Interface BookDao{
	public void update();
}

public class BookDaoImpl implements BookDao{
		public void update(){
			System.out.println("book dao update ...");
		}
}

描述方式一：执行com.hcx.dao包下的BookDao接口中的无参数update方法

execution(void com.hcx.dao.BookDao.update())

描述方法二：执行com.hcx.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void com.hcx.iml.BookDaoImpl.update())

  • 切入点表达式标准格式：动作关键字（访问修饰符，返回值，包名，类/接口.方法名(参数)异常名）

    execution(public User com.hcx.service.UserService.findById(int))

  • 动作关键字：描述切入点的行为动作，例如excution表示执行到指定切入点

  • 访问修饰符：public，private 等，可以省略

  • 返回值

  • 包名

  • 类/接口名

  • 方法名

  • 参数

  • 异常名：方法定义中抛出异常，可以省略

AOP通知类型

  • AOP通知描述了抽取的共性功能，根据共性功能抽取位置不同，最终运行代码时要将其加入到合理的位置

  • AOP通知分为5种类型

    • 前置通知
    • 后置通知
    • 环绕通知（重点）
    • 返回通知（了解）
    • 抛出执行异常后通知（了解）

  • 名称：@Around(重点，常用)

  • 类型：方法注释

  • 位置：通知方法定义上方

  • 作用：设置当前通知方法与切入点之间的绑定关系，当通知方法在原始切入点方法前后运行

  • 范例：

    @Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("around before advice ...");
Object ret = pjp.proceed();
System.out.println("arround after advice ...");
return ret;
}

    • @Around注意事项

      1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
      2. 通知中如果为使用ProceedIngJoinPoint对原始方法进行调用将跳过原始方法的执行
      3. 对原始方法的调用可以不接收返回值，通知方法设置称void即可，如果接收返回值，必须设定为Object类型
      4. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
      5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象
      @Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("around before advice ...");
Object ret = pjp.proceed();
System.out.println("around after advice ...");
return ret;
}

      • 名称：@AfterReturning(了解)

      • 类型：方法注解

      • 位置：通知方法定义上方

      • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行

      • 范例：

        @AfterReturning("pt()")
public void after Returning(){
System.out.println("afterReturning advice ...");
}

      • 相关属性：value（默认）：切入点方法名，格式为类名.方法名（）

      • 名称：@AfterThrowing(了解)

      • 类型：方法注解

      • 位置：通知方法定义上方

      • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

      • 范例：

      @AfterThorwing("pt()")
public void afterThorwing(){
	System.out.println("afterThrowing advice ...");
}

    • 相关属性：value（默认）：欺辱点方法名，格式为：类名.方法名（）

案例：测量业务层接口万次执行效率

步骤一：

@Around("ProjectAdvice.serbicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable{
	long start = System.currentTimeMillis();
    //获取执行签名信息
    Singnature signature= pjp.getSignature();
    //通过签名获取执行类型（接口名）
    Stirng className = signature.getDeclaringTypeName();
    String methodName = signature.getName();
	for(int i= ; i< 10000;i++){
		pjp.proceed();
	}
	long start =System.currentTimeMillis();
	System.out.println("业务层接口万次执行"+className+"."+methodnName+"时间
："+(end-start))+"ms"
}

需求：任意业务层接口军可执行显示器执行效率（执行时长）

分析：

  • 业务层功能：业务接口执行前后分别记录时间求差值得到执行效率
  • 通知类型选择前后均可增强的类型——环绕通知

AOP通知获取数据

AOP通知获取参数数据

  • 获取切入点方法的参数

    • JoinPoint:适用于前置，后置，返回后，抛出异常通知
    • ProceedJointPoint:适用于环绕通知

  • 获取切入点方法返回值

    • 返回后通知
    • 环绕通知

  • 获取切入点方法运行异常信息

    • 抛出异常后通知
    • 环绕通知

  • JointPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
public void before(JointPoint jp){
	Object[] args = jp.getArgs();
	System.out.println(Arrays.toString(args));
}
  • ProceedJointPoint的子类
public Object around(ProceedingJointPoint pjp) threos Throwable{
	Object[] args = pjp.getArgs();
	System.out.println(Arrays.toString(args));
	Object ret = pjp.proceed();
	return ret;	
}

AOP通知获取返回值数据

  • 抛出异常后通知可以获取切入点方法中的异常信息，使用形参可以接收对应的异常对象
@AfterReturning(Value = "pt()",returning = "ret")
public void afterReturning(String ret){
	System.out.println("afterRetruning advice ..."+ ret);
}
  • 环绕通知中可以手工书写对原始方法的调用，得到结果即为原始方法的返回值
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
	Object ret = pjp.proceed();
	return ret;
}

AOP通知获取异常数据（了解）

  • 抛出异常后通知可以获取切入点帆帆中出现的异常信息，是用形参可以接收对应的异常对象
@AfterThrowing(value = "pt()",throwing ="t")
public void afterThrowing(Throwable t){
 System.out.println("afterThrowing adivce ..."+ t);
}
  • 抛出异常后通知可以回去切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象
@Around("pt()")
public Object around(ProceedingJoinPoint pjp){
	Object ret = null;
	try{
		ret= pjp.proceed();
	}catch(Throwable t){
		t.printStackTrace();
	}
	return ret;
}

总结

AOP通知获取数据

  • 参数
  • 返回值
  • 异常

案例：百度网盘密码数据兼容处理

案例：百度网盘分析链接输入密码数据错误兼容性处理

分析：

  1. 在业务方法执行前对之前对所有的输入输出参数进行格式处理——trim()
  2. 使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用
@Around("DataAdvice.servicePt()")
public Object trimString(ProceedingJoinPoint pjp) throws Throwable{
	Object[] args = pjp.getArgs();
	//对原始参数的每一个参数进行操作
	for(int i = 0; i < args.leng ; i++){
	//如果是字符串数据
	if(args[i].getClass().equals(String.class)){
	//取出数据，trim()操作后，更新数据
	args[i] = args[i].toString().trim();
	}
	}
	return pjp.proceed(args);
}

AOP总结

核心概念

  • 概念：AOP面向切面编程，是一种编程范式
  • 作用：在不惊动原始设计的基础上为方法进行功能增强
  • 核心概念
    • 代理（Proxy）:SpringAOP的本质核心就是采用代理模式实现的
    • 连接点（JoinPoint）：在SpringAop中，理解为任意方法的执行
    • 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
    • 通知（Advice）：若干个方法的共性，在切入点处执行，最终体现为一个方法
    • 切面（Aspect）：描述通知与欺辱点对应关系
    • 目标对象（Target）：被代理的原始对象称为目标对象

切入点

  • 切入点表达式标准格式，动作关键字（访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名 ）
    • excution(* com.hcx.service.*Service.*(..))
  • 切入点表示描述统配符：
    • 作用：用于快速描述，范围描述
    • *：匹配任意符号（常用）
    • …：匹配多个连续任意符号（常用）
    • +：匹配子类类型
  • 切入点表达式书写技巧
    1. 按标准规范开发
    2. 查询操作的返回值建议在使用 * 匹配
    3. 减少使用…去描述包
    4. 对接口进行描述，使用表示模块名，例如UserService的匹配描述为Service
    5. 方法名书写保留动词，例如get，使用表示名称，例如getById匹配描述为getBy
    6. 参数更卷实际情况灵活调整

环绕通知

  • 通知类型
    • 前置通知
    • 后置通知
    • 环绕通知（重点）
      • 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
      • 环绕通知可以隔离原始方法的调用执行
      • 环绕通知返回设置为Objec类型
      • 环绕通知中可以对原始方法调用过程中出现的异常进行处理
    • 返回后通知
    • 抛出异常后通知

AOP通知获取数据

  • 获取切入点方法的参数
    • JoinPoint：适用于前置，后置，返回后，抛出异常后通知，设为方法发第一个形参
    • ProceedJointPoint:适用于环绕通知
  • 获取切入点方法返回值
    • 返回后通知
    • 环绕通知
  • 获取切入点方法运行异常信息
    • 抛出异常后通知
    • 环绕通知

Spring事务简介

  • 事务作用：在数据层保障一系列的数据库操作同成功同失败
  • Spring事务作用：在数据层或业务层保障一系列的数据操作同成功同失败
public interface PlatformTransactionManager{
	void commit(TransactionStatus status) throws TransactionException;
	void rollback(TransactionSattus status) throws TransactionException;
}

public class DataSourceTransactionManager{
	...
}

案例：银行账户转账

需求：实现任意两个账户间转账操作

需求微缩：A账户减钱，B账户加钱

分析:

  1. 数据层提供基础操作，指定账户减钱（outMoney）,指定账户加钱（inMoney）
  2. 业务层提供转账操作（transfer），调用减钱和加钱的操作
  3. 提供2个账号和操作金额执行转账操作
  4. 基于Spring整合MyBatis环境搭建上述操作

结果分析：

  1. 程序正常执行时，账号金额A减B加，没有问题
  2. 程序出现异常，转账失败，单是异常之前操作成功，异常之后操作失败，整体业务失败

添加事务管理操作流程

  1. 在业务层接口上添加Spring事务管理

    public interface AccountService{
	@Transactional
	public void transfer(String out,String in,Double money);
}

    注意：Spring注解式事务通常添加在业务层接口中而不会添加到业务层实习类中，降低耦合度

    ​ 注解式业务可以添加到业务方法上表示开启事务，也可以添加到接口上表示当前接口所有方法开启事务

  2. 设置事务管理

    @Bean
public PlatformTransactionManager transactionManager(DataSource dataSoure){
	DataSouceTransactionManager ptm = new DataSourceTransactionManager();
	ptm.setDataSource(dataSource);
	return ptm;
}

    注意：事务管理要根据实现技术进行选择

    ​ MyBatis框架使用JDBC事务

  3. 开启注解事务驱动

    @Configuration
@ComponentScan("com.hcx")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig{
}

Spring事务角色（通过相同数据源来管理）

  • 事务角色
    • 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
    • 事务协调员：加入事务方，在Spring中通常带着数据层方法，也可以是业务层方法

事务相关配置

黑马程序员2022新版SSM框架Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus企业实用开发技术——万字学习笔记：Spring+SpringMVC篇_第1张图片

注意：IOException不属于运行时异常，事务回滚不管理

事务传播行为

  • 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

Spring中七种事务传播行为

事务传播行为类型 说明
PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

黑马程序员2022新版SSM框架Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus企业实用开发技术——万字学习笔记：Spring+SpringMVC篇_第2张图片案例：转账业务追加日志

需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕

需求微缩：A账户减钱，B账户加钱，数据库记录日志

分析：

  1. 基于转账操作案例添加日志模块，实现数据库中记录日志
  2. 业务层转账操作（transfer），调用减钱，加钱与记录日志功能

实现效果预期：

无论转账是否成功，均进行转账操作的日志留痕

存在问题：

日志的记录与转账操作隶属于同一事务，同成功同失败

失效效果预取改进：

无论转账操作是否成功，日志必须保留

步骤

  1. 在业务层接口上添加Spring事务，设置事务传播行为REQUIRES_NEW（需要新事务）
@Service
public class LogServiceImpl implements LogService{
	@Autowired
	private LogDao logDao;
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void log(String out,String in,Double money){
		logDao.log("转账操作由"+out+"到"+in+",金额："+money)；
	}
}

SpringMVC

  • SpringMVC技术与Servlet技术功能相同，均属于web层开发技术，但SpringMVC技术更简洁，能用更少的代码进行开发

SpringMVC概述

  • SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
  • 功能
    • 用于进行表现层功能开发
  • 优点
    • 使用简单，开发便捷（相比于Servlet）
    • 灵活性强

SpringMVC入门案例

  1. 使用SpringMVC技术需要县导入SpringMVC坐标与Servlet坐标

     
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>3.1.0version>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>

  2. 创建SpringMVC控制器类（等同于Servlet功能）

    @Controller
public class UserController{
	@RequestMapping("/save")
	@ResponseBody
	public String save(){
		System.out.println("user save ...");
		return "{'module':'springmvc'}";
	}
}

  3. 初始化SpringMVC环境（同Spring环境），设定SpringMVC加载对应的bean

    @Configuration
@ComponentScan("com.iteima.controller")
public class SpringMvcConfig{
}

  4. 初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理请求

    import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

//4.定义一个servlet容器启动的配置类，在里面加载spring的配置
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springMVC容器配置
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(SpringMvcConfig.class);
        return context;
    }
    //设置哪些请求归属springMVC处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
	//加载spring容器配置
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

    入门案例用到的注解

    • 名称：@Controller

    • 类型：类注解

    • 位置：SpringMVC控制器定义上方

    • 作用：设置SpringMVC的核心控制器bean

    • 范例：

      @Controller
public class UserController{
}

    • 名称：@ResquestMapping

    • 类型：方法注释

    • 位置：SpringMVC控制器方法定义上方

    • 作用：设置当前控制器方法请求访问路径

    • 范例：

      @ResquestMapping("/save")
public void save(){
	System.out.println("user save ...");
}

    • 相关属性

      • value(默认)：请求访问路径

    • 名称：@ResponseBody

    • 类型：方法注释

    • 位置：SpringMVC控制器方法定义上方

    • 作用：设置当前控制器方法响应内容为当前返回值，无需解析

    • 范例：

      @RequestMapping("/save")
@ResponseBody
public String save(){
System.out.println("user save ...");
return "{'info':"springmvc"}";
}

    • SpringMVC入门程序开发总结（1+N）

      • 一次性工作
        • 创建工程，设置服务器，加载工程
        • 导入坐标
        • 创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
        • SpringMVC核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
      • 多次工作
        • 定义处理请求的控制器类
        • 定义处理请求的控制器方法，并配置映射路径（@RequestMapping）与返回json数据（@ResponseBody）

Servlet容器配置类

  • AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化web3.0容器的抽象类

  • AbstractDispatcherServletInitializer提供三个接口方法供用户实现

    • createServletAppilcationContext（）方法，创建servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围

      protected WebApplicationContext createServletApplicationContext(){
AnnotattionConfigWebApplicationContext context = new AnnotattionConfigWebAppklicationtContext();
context.register(SpringMvcConfig.class);
return context;
}

    • getServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将转入道SpringMVC进行处理

      protected String[] getServletMapping(){
	return new String[]("/");
}

    • createRootApplicationContext()方法，如果创建Servlet容器时需要加载飞SpringMVC对应的bean，使用当前方法进行，使用方式用createServletAppilcationContext（）

      protected WebApplicationContext createRootApplicationContext(){
return null;
}

      入门案例工作流程分析

      • 启动服务器初始化过程
        1. 服务器启动，执行ServletContainersInitConfig类，初始化web容器
        2. 执行createServletApplicationContext方法，创建了WebApplicationContext对象
        3. 加载SpringMvcConfig
        4. 执行@ComponentScan加载对应的bean
        5. 加载UserController，每过@RequestMapping的名称对应一个具体的方法
        6. 执行getServletMappings方法，定义所有请求都通过SpringMVC
      • 单次请求过程
        1. 发射请求localhost/save
        2. web容器发现所有请求都经过SpringMVC，将请求交割SpringMVC处理
        3. 解析请求路径/save
        4. 由/save匹配执行对应的方法saev()
        5. 执行save()
        6. 检测道由@ResponseBody之际将save()方法的返回值作为响应体返回给请求方

Controller加载控制与业务bean加载控制

  • SpringMVC相关bean（表现层bean）
  • Spring控制的bean
    • 业务bean（Service）
    • 功能bean（DatatSource等）
  • SpringMVC相关bean加载控制
    • SpringMVC加载的bean对应的包均在com.hcx.controller包内
  • Spring相关bean加载控制
    • 方式一：Spring加载的bean设定扫描范围为com.hcx,排除controller包内的bean
    • 方式二：Spring加在的bean设定扫描范围为精准范围，例如service包，dao包等

注解复习

  • 名称：@ComponentScan

  • 类型：类注解

  • 范例：

    @Configuration
@ConmponentScan(value="com.itheima",
	excludeFilters = @ComponentScna.Filter(
		type = FilterType.ANNOTATION,
		classer = Controller.class
		)
)
public class SpringConfig{}

  • 属性

    • excludeFilters: 排除扫描路径中加载的bean，需要指定类别（type）与具体项（classer）
    • includeFilters: 加载指定的bean，需要指定类别（type）与具体项（class）

  • bean的加载格式

    //4.定义一个servlet容器启动的配置类，在里面加载spring的配置
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springMVC容器配置
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(SpringMvcConfig.class);
        return context;
    }
    //设置哪些请求归属springMVC处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
//加载spring容器配置
    @Override
    protected WebApplicationContext createRootApplicationContext() {
         AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(SpringConfig.class);
        return context;
    }
}

  • 简化开发

    public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[0];
        /* return new Class[]{SpringConfig.class}*/
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

请求与响应

  • 名称：@RequestMapping

  • 类型：方法注解 类注解

  • 位置：SpringMVC控制器方法定义上方

  • 作用：设置当前控制器方法请求访问路径，如果设置在类上统一设置当前方法请求访问路径前缀

  • 范例：

    @Controller
@RequestMapping("/user")
public class UserController{
	@RequestMapping("/save")
	@ResponseBody
	public String save(){
		System.out.println("user save ...");
		return "{'module':'user save'}";
	}
}

  • 属性

    • value(默认)：请求访问路径，或访问路径前缀
中文乱码处理
Post请求中文乱码处理

  • 为web容器添加过过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
请求参数

  • 参数种类

    • 普通参数
    • POJO类型参数
    • 嵌套POJO类型参数
    • 数组类型参数
    • 集合类型参数

  • 普通参数：url 地址穿参，地址参数名与形参变量名相同，定义形参即可接收参数

    @RequestMapping("/commoParam")
@ResponseBody
public String commonParam(String name,int age){
	Stystem.out.println("普通参数传递 name ==> " + name );
	System.out.println("普通参数 age ==> " + age);
	return "{'module':'common param'}";
}
使用到的注解

  • 名称：@RequestParam

  • 类型：形参注解

  • 位置：SpringMVC控制器方法形参定义前面

  • 作用：绑定请求参数与处理器方法形参间的关系

  • 范例：

    @RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(@RequestParam("name") String userName , int age){
 	System.out.println("普通参数 userName ==>" + userName);
 	System.out.println("普通参数 userName ==>" + age);
 	return "{'module':'common param different name'}";
}

  • 参数：

    • required: 是否为必传参数
    • defaultValue：参数默认值
POJO参数/嵌套的POJO参数

  • POJO参数/嵌套的POJO参数：请求数名与形参对象属性名相同，定义POJP类型形参即可接收参数

    //嵌套pojo参数
    @RequestMapping("/saveObj")
    @ResponseBody
    public String saveObj(User user){
        System.out.println("对象接收数据"+user);
        return "{'module':'pojo contain pojo param'}";
    }
Json数据传参

请求参数

  • json数组
  • json对象（POJO）
  • json数组（POJO）
步骤一：导入JSON的pom坐标

    <dependency>
      <groupId>com.fasterxml.jackson.coregroupId>
      <artifactId>jackson-databindartifactId>
      <version>2.12.4version>
    dependency>
步骤二：设置发送json数据（请求body中添加json数据）
步骤三：在SpringMvcConfig.class里面加入@EnableWebMvc，开启自动转换json数据的支持
//3.创建springmvc的配置文件，加载controller对应的bean
@Configuration
//@ComponentScan("com.hcx.controller")
@ComponentScan(value = "com.hcx"/*, excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)*/)
@EnableWebMvc
public class SpringMvcConfig {
}
第四步：在Controller（控制层）编写代码，设置json数据
//集合参数：JSON格式
    @RequestMapping("/listParamJson")
    @ResponseBody
    public String listParamJson(@RequestBody List<String> list){
        System.out.println("集合参数传递 list ==>" + list);
        return "{'module':'listJson param'}";
    }
    //POJO参数：JSON格式
    @RequestMapping("/pojoParamJson")
    @ResponseBody
    public String pojoParamJson(@RequestBody User user){
        System.out.println("pojo(json)参数传递 user ==>"+user);
        return "{'module':'pojoJson param'}";
    }
    //对象集合类型：JSON格式
    @RequestMapping("/listUserParamJson")
    @ResponseBody
    public String listUserParamJson(@RequestBody List<User> list){
        System.out.println("List参数传递 ==>" + list);
        return "{'module':'ListJson param'}";
    }
注解复习

  • 名称：@EnableWebMvc

  • 类型：配置类注解

  • 位置：SpringMVC配置定义上方

  • 作用：开启SpringMVC多项负责功能

  • 范例：

    //3.创建springmvc的配置文件，加载controller对应的bean
@Configuration
//@ComponentScan("com.hcx.controller")
@ComponentScan(value = "com.hcx"/*, excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)*/)
@EnableWebMvc
public class SpringMvcConfig {
}

  • 名称：@RequestBody

  • 类型：形参注解

  • 位置：SpringMVC控制器方法形参定义前面

  • 作用：将请求中请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次

  • 范例：

    @RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
 	System.out.println("list common(json)参数传递 list ==>"+ likes);
 	return "{'moudle':'list common for json param'}";
}
@RequestBody与@RequestParam区别
  • 区别
    • @RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
    • @RequestBody用于接收json数据【application/json】
  • 应用
    • 后期开发中，发送json格式数据为主，@ResquestBody应用较广
    • 如果发送飞json格式数据，选用@RequestParam接收请求参数
日期类型参数传递

  • 日期类型数据基于系统不同格式也不尽相同

    • 2022-08-30
    • 2022/08/30
    • 08/18/2022

  • 接收形参是，根据不同的日期格式设置不同的接收方式

    @RequestMapping("/dateParam")
@ResponseBody
public String dateParam(Date date,
						@DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
						@DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss")Date date2){
						System.out.println("参数传递 date ==>" + date);
						System.out.println("参数传递 date(yyyy-MM-dd) ==>" + date1);
						System.out.println("参数传递 date(yyyy/MM/dd HH:mm:ss) ==>" + date2);
			retrun "{'module':'data param'}";				
		}
日期类型注解

  • 名称：@DateTimeFormat

  • 类型：形参注解

  • 位置：SpringMVC控制器方法形参前面

  • 作用：设定日期时间型数据格式

  • 范例：

    @RequestMapping("/dateParam")
@ResponseBody
public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
	System.out.println("参数传递 date ==>" + date);
	retrun "{'module':'data param'}";	
}

  • 属性：pattern = “日期时间格式字符串”

类型转化器

  • Converter接口

    public interface Converter<S,T>{
	@Nullable
	T convert(S source);
}
    • 请求参数年龄数据（String+Integer）
    • 日期格式转换 （String -> Date）

  • @EnableWebMvc功能之一：根据类型匹配对应类型转换器

响应

  • 响应页面

  • 响应数据

    • 文本数据
    • JSON数据

  • 响应文本数据

    @RequestMapping("/toText")
@ResponseBody
public String toText(){
	return "response text";
}

  • 响应json数据（对象转json）

    //响应POJO对象数据
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回json对象数据");
        User user = new User();
        user.setName("hcx");
        user.setAge(21);
        user.setAddress(new Address("南昌","江西"));
        return user;
    }

  • 响应对象集合转json数组

    //响应POJO集合对象
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        System.out.println("返回json对象集合");
        User user= new User();
        user.setName("开源协议");
        user.setAge(21);
        user.setAddress(new Address("南昌","江西"));

        User userOne= new User();
        userOne.setName("阿里巴巴开发手册");
        userOne.setAge(15);
        userOne.setAddress(new Address("杭州","浙江"));

        List<User> userList = new ArrayList<>();
        userList.add(user);
        userList.add(userOne);
        return userList;
    }
注解复习

  • 名称：@ResponseBody

  • 类型：方法注解

  • 位置：SpringMVC控制器方法定义上方

  • 作用：设置当前控制器方法响应内容为当前返回值，无需解析

  • 范例：

    @RequestMapping("/save")
@ResponseBody
public String save(){
	System.out.print("Save...");
	return "{'info':'springmvc'}";
}

  • HttpMessageConverter接口

    public interface HttpMessageConverter<T> {
    boolean canRead(Class<?> var1, @Nullable MediaType var2);

    boolean canWrite(Class<?> var1, @Nullable MediaType var2);

    List<MediaType> getSupportedMediaTypes();

    T read(Class<? extends T> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;

    void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3) throws IOException, HttpMessageNotWritableException;
}

REST风格

  • REST（Representational State Transfer）,表现形式状态转换

    • 传统风格资源描述形式

      http://localhost/user/getById?id=1

      http://localhost/user/saveUser

    • REST风格描述形式

      http://localhost/user/1

      http://localhost/user

  • 优点：

    • 隐藏资源的访问行为，无法通过地址得治对资源是何种操作
    • 简化书写
REST风格简介
  • 安装REST风格访问资源是使用行为动作区分对资源进行何种操作
    • http://localhost/users 查询全部用户信息 GET （查询）
    • http://loocalhost/users/1 查询指定用户信息 GET（查询）
    • http://localhost/users 添加用户信息 POST（新增/保存）
    • http://localhost/users 修改用户信息 PUT（修改/更新）
    • http://localhost/users/1 删除用户信息 DELETE（删除）

注意事项：

上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范

描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users，books,accounts…

RESTful入门案例

  1. 设定http请求动作（动词）

    @RequestMapping(value="/users",method =RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
	System.out.println("user save..." + user);
	return "{'module':'user save'}";
}

@RequestMapping(value="/users",method=RequestMethod.PUT)
@ResponseBody
publiic String update(@RequestBody User user){
	System.out.println("user update ..."+ user);
	return "{'module':'user update'}";
}

  2. 设置请求参数（路径变量）

    @RequestMapping(value ="/users/{id}",method =RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
 System.out.println("user delete ..."+ id);
 return "{'module':'user deleter'}";
}
    注解复习

    • 名称：@PathVariable

    • 类型：形参注解

    • 位置：SpringMVC控制器方法形参定义前面

    • 作用：绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应

    • 范例：

      @RequestMapping(value = "/users/{id}",method =RequestMethod.DELETE)
@ResponseBody
public String save(@PatVariable Integer id){
	System.out.println("user delete ..." + id);
	return "{'module':'user delete'}";
}

    • 名称：@RequestMapping

    • 类型：方法注解

    • 位置：SpringMVC控制器定义上方

    • 作用：设置当前控制器方法请求访问路径

    • 范例：

      @RequestMapping(value = "/users",method =RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
	System.out.println("user save ..." + user);
	return "{'module':'user save'}";
}

    • 属性

      • value(默认)：请求访问路径
      • method:http请求动作，标准动作（POST/GET/PUT/DELETE）
@RequestBody @RequestParam @PathVariable
  • 区别
    • @RequestParam用于接收url地址传参或表单传参
    • @RequestBody用于接收JSON数据
    • @PathVariable用于接收路径参数，使用{参数名称}描述路径参数
  • 应用
    • 后期开发中，发送请求参数超过一个时，以json格式为主，@RequestBody应用较广
    • 如果发送非json格式数据，选用@RequestParam接收请求参数
    • 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收路径变量，常用于传递id值
RESTful快速开发
@RequestMapping(value="/books",method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody Book book){
	System.out.println("book save ..."+ book);
	return "{'module':'book save'}";
}
@RequestMapping(value="/books",method = RequestMethod.PUT)
@ResponseBody
public String save(@RequestBody Book book){
	System.out.println("book update ..."+ boook);
	return "{'module':'book update'}";
}
合并注解事项简化开发

  • 名称：@RestController

  • 类型：类注解

  • 位置：基于SpringMVC的RESTful开发控制器类定义上方

  • 作用：设置当前控制器类为RESTful风格，等同于@Controller与@ResponseBody两个注解组合功能

  • 范例：

    @RestControoler
public class BookController{
}

  • 名称：@GetMapping @PostMapping @PutMapping @DeleteMapping

  • 类型：方法注解

  • 位置：基于SpringMVC的RESTful开发控制器方法定义上方

  • 作用：设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，例如@GetMapping对应Get请求

  • 范例：

    @GetMapping("/{id}")
public String getById(@PathVariable Integer id){
    System.out.pringln("book getById ..." + id);
    return "{'module':'book getById'}";
}

  • 属性

    • value(默认)：请求访问路径
案例：基于RESTful页面数据交互

  1. 制作SpringMVC控制器，并通过PostMan测试接口功能

    @RestController
@RequestMapping("/books")
public Class BookController{
	@PostMapping
	public String save(@RequestBody Book book){
		System.out.println("book save ==>" + book);
		return "{'moudule':'book save success'}";
	}
	@GetMapping
    public List<Book> getAll(){
        List<Book> bookList = new ArrayList<>();
        Book book = new Book();
        book.setType("计算机");
        book.setName("SpringMVC入门教程");
        book.setDescription("小试牛刀");
        bookList.add(book);
        Book book1 = new Book();
        book1.setType("计算机");
        book1.setName("SpringMVC入门教程");
        book1.setDescription("加油");
        bookList.add(book1);
        //模拟数据
        return bookList;
    }
}

  2. 设置对静态支援的访问通行

    @Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/？？？不要走mvc，走/pages目录下的内容访问
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        //放行js
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
	   //放行css
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        //放行插件
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

  3. 前端页面通过异步提交访问后台控制器

    //添加
saveBook(){
	axios.post("/books",this.formData).then((res)=>{
	
	});
},

//主页列表查询
getAll(){
	axios.get("/books").then((res)=>{
		this.dataList = res.data;
	});
},

  4. 总结

    • 先做后台功能，开发接口并调通接口
    • 再做页面异步调用，确认功能可以正常访问
    • 最后再完成页面数据的显示
    • 补充：放行静态资源访问

SSM整合

概览

  • SSM整合
  • 表现层数据封装
  • 异常处理器
  • 项目异常处理方案
  • 案例：SMM整合标准开发

SSM整合流程

  1. 创建工程，并导入坐标

    

<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.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>springmvc_08_ssmartifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>warpackaging>
    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.12version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.2.10.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
            <version>5.2.10.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.2.10.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.6version>
        dependency>
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatis-springartifactId>
            <version>1.3.2version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.47version>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.2.11version>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
            <scope>providedscope>
        dependency>
        
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
            <version>2.9.0version>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <version>2.1version>
                <configuration>
                    <port>8080port>
                    <path>/path>
                configuration>
            plugin>
        plugins>
    build>
project>

  2. SSM整合

    • Spring

      • SpringConfig

        @Configuration
@ComponentScan("com.hcx")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
public class SpringConfig{
}

    • MyBatis

      • MybatisConfig

        import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean factoryBean =  new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.hcx.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer=new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.hcx.dao");
        return mapperScannerConfigurer;
    }
}

      • JdbcConfig

        public class JdbcConfig{
	@Value("${jdbc.driver}")
	private String driver;
	@Value("${jdbc.url}")
	private String url;
	@Value("${jdbc.username}")
	private String userName;
	@Value("${jdbc.password}")
	private String password;
	@Bean
	public DataSource dataSource(){
	DruidDataSource dataSource = new DruidDataSource();
	 dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
	}
    
    //开启事务管理
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

      • jdbc.properties

        jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=******

    • SpringMVC

      • ServletConfig

        package com.hcx.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理——post表单提交时处理中文乱码
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

      • SpringMvcConfig

        import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@ComponentScan("com.hcx.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

  3. 功能模块

    • 表与实体类

      import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;

}

    • dao（接口+自动代理）

      import com.hcx.domain.Book;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.stereotype.Repository;

import java.util.List;

public interface BookDao {
    /*写法一：@Insert("insert into tbl_book values(null,#{type},#{name},#{description})")*/
    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public void save(Book book);

    @Update("update tbl_book set type= #{type},name = #{name},description = #{description} where id = #{id}")
    public void update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);

    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    @Select("select * from tbl_book")
    public List<Book> getAll();
}

    • service（接口+实现类）

      • 接口
      import com.hcx.domain.Book;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Transactional
public interface BookService {
    /**
     * 保存
     * @param book
     * @return
     */
    public Boolean save(Book book);

    /**
     * 修改
     * @param book
     * @return
     */
    public Boolean update(Book book);

    /**
     * 根据id删除
     * @param id
     * @return
     */
    public Boolean delete(Integer id);

    /**
     * 根据id查询
     * @param id
     * @return
     */
    public Book getById(Integer id);

    /**
     * 查询全部
     * @return
     */
    public List<Book> getAll();
}

      实现类

      import com.hcx.dao.BookDao;
import com.hcx.domain.Book;
import com.hcx.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    public Boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    public Boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    public Boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
        return bookDao.getById(id);
    }

    public List<Book> getAll() {

        return bookDao.getAll();
    }
}

      • 业务层接口测试（整合JUnit）

        import com.hcx.config.SpringConfig;
import com.hcx.domain.Book;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {
    @Autowired
    private BookService bookService;
    @Test
    public void testGetById(){
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
        List<Book> list=bookService.getAll();
        System.out.println(list);
    }
}

    • controller

      import com.hcx.domain.Book;
import com.hcx.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;


    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK : Code.SAVE_ERR, flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK : Code.UPDATE_ERR, flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK : Code.DELETE_ERR, flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book=bookService.getById(id);
        Integer code = book != null ? Code.GET_OK:Code.GET_ERR;
        String msg = book != null ? "数据查询成功" : "数据查询失败请重试";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_ALL_OK:Code.GET_ALL_ERR;
        String msg = bookList != null ? "全部数据查询成功":"数据查询失败请重试";
        return new Result(code,bookList,msg);
    }
}

      数据传输协议所要用到的bean

      Result.java

      import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Result {
    private Integer code;
    private Object data;
    private String msg;

    public Result(Integer code, Object data) {
        this.code = code;
        this.data = data;
    }
}

      Code.java

      public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    public static final Integer GET_ALL_OK = 20051;
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
    public static final Integer GET_ALL_ERR = 20050;
}
      • 表现层接口测试（Apifox）

SSM整合-表现层与前端数据传输协议定义

数据返回格式：

{
	"code":Integer,
	"data":Obj,
	"msg":String
}

完成方式：

在Controller里面添加Result类和Code类，并让Controller里面的方法都返回Result类型的结果

SSM整合-异常处理

异常处理器

  • 程序开发过程中不可避免的会出现异常
  • 出现异常现象的常见位在与常见诱因如下：
    • 框架内部抛出异常：因使用不规范导致
    • 数据层抛出的异常：因为外部服务器故障导致（例如：服务器访问超时）
    • 业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
    • 表现层抛出的异常：因数据收集，校验规则导致（例如：不匹配的数据类型间导致异常）
    • 工具类抛出异常：因工具类书写不严谨不狗健壮导致（例如：必要释放的连接长使劲啊未释放等）

  1. 各个层级均出现异常，异常处理代码书写在哪一层

    ——所有的异常均抛出到表现层处理

  2. 表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决——AOP思想

  • 定义异常处理器

    • 集中的，统一的处理项目中出现的异常
    @ResControllerAdvice
public class ProjectExceptionAdvice{
	@ExceptionHandler(Exception.class)
	public Result doExpetion(Exception ex){
		System.out.println("异常被捕获");
		return new Result(001,null,"异常被捕获");
	}
}

注解使用：

  • 名称：@RestControllerAdvice

  • 类型：类注解

  • 位置：Rest风格开发的控制器增强类定义上方

  • 作用：为Rest风格开发的控制器类做增强

  • 范例：

    @ResControllerAdvice
public class ProjectExceptionAdvice{
}

  • 说明：

    • 此注解自带@ResponseBody注解与@Component注解，具备对应的功能

  • 名称：@ExceptionHandler

  • 类型：方法注解

  • 位置：专用于异常处理的控制器上方

  • 作用：设定指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前方法执行

  • 范例：

    @RestControllerAdvice
public class ProjectExceptionAdvice{
	@ExceptionHandler(Exception.class)
	public Result doException(Exception exception){
		return new Result(001,null,"异常已被捕获")
	}
}

  • 说明：

    • 此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

SSM整合-项目异常处理方案

  • 项目异常分类

    • 业务异常（BusinessException）
      • 规范的用户行为产生的异常
      • 不规范的用户行为操作产生的异常
    • 系统异常（SystemException）
      • 项目运行过程中可预计且无法避免的异常
    • 其他异常（Exception）
      • 编程人员为预期到的异常

  • 项目异常处理方案

    • 业务异常（BusinessException）
      • 发送对应消息传递给用户，提醒规范操作
    • 系统异常（SystemException）
      • 发送固定消息传递给用户，安抚用户
      • 发送特定消息给运维人员，提醒维护
      • 记录日志
    • 其他异常（Exception）
      • 发送固定消息给用户，安抚用户
      • 发送特定消息给编程人员，提醒维护（纳入预期范围内）
      • 记录日志

项目异常处理

  1. 自定义项目系统级异常

    public class SystemException extends RuntimeException{
    private  Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code,String message ) {
        super(message);
        this.code = code;
    }

    public SystemException(Integer code,String message, Throwable cause ) {
        super(message, cause);
        this.code = code;
    }

    public SystemException(Integer code,Throwable cause ) {
        super(cause);
        this.code = code;
    }

    public SystemException(Integer code,String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.code = code;
    }
}

  2. 自定义项目业务级异常

    public class BusinessException extends RuntimeException{
    private  Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException(Integer code) {
        this.code = code;
    }

    public BusinessException(Integer code, String message ) {
        super(message);
        this.code = code;
    }

    public BusinessException(Integer code, String message, Throwable cause ) {
        super(message, cause);
        this.code = code;
    }

    public BusinessException(Integer code, Throwable cause ) {
        super(cause);
        this.code = code;
    }

    public BusinessException(Integer code, String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.code = code;
    }
}

  3. 自定义异常编码（持续补充）

    public class Code{
public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    public static final Integer GET_ALL_OK = 20051;
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
    public static final Integer GET_ALL_ERR = 20050;

    public static final Integer SYSTEM_ERR = 20060;
    public static final Integer SYSTEM_TIMEOUT_ERR = 20070;

    public static final Integer BUSINESS_ERR = 20080;
    public static final Integer SYSTEM_UNKNOW_ERR = 20090;
}

  4. 触发定义异常

    @Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    public Boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    public Boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    public Boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
        //模拟业务异常
        if(id == 1){
            throw new BusinessException(Code.BUSINESS_ERR,"访问连接过多异常");
        }
        //将可能出现的异常进行包装，转换称自定义异常
        try {
            int i = 1/0;
        }catch (Exception exception){
            throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重试",exception);
        }
        return bookDao.getById(id);
    }

    public List<Book> getAll() {
        return bookDao.getAll();
    }
}

  5. 拦截并处理异常

    @RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public Result doException(Exception exception) {
        //记录日志(错误堆栈)
        //发送消息给运维
        //发送邮件给开发人员，exception对象发送给开发人员
        System.out.println("其他异常被捕获");
        return new Result(Code.SYSTEM_UNKNOW_ERR, null, "系统繁忙请稍后再试");
    }

    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException exception) {
        //记录日志(错误堆栈)
        //发送消息给运维
        //发送邮件给开发人员，exception对象发送给开发人员
        System.out.println("系统异常被捕获");
        return new Result(exception.getCode(), null, exception.getMessage());
    }

    @ExceptionHandler(BusinessException.class)
    public Result doSystemException(BusinessException exception) {
        System.out.println("业务异常被捕获");
        return new Result(exception.getCode(), null, exception.getMessage());
    }
}

  6. 异常处理效果对比

总结：

  • 异常处理器
  • 自定义异常
  • 异常编码
  • 自定义消息

SSM整合标准开发

…

SpringMVC拦截器

拦截器概念

  • 拦截器（Interceptor）是一种动态拦截方法调用的机制，再SpringMVC中动态拦截控制器方法的执行
  • 作用：
    • 在指定的方法调用前后执行预先设定的代码
    • 阻止原始方法的执行

拦截器和过滤器的区别

  • 归属不同：Filter属于Servlet计算，Interceptor属于SpringMvc技术
  • 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

拦截器入门案例

  1. 制作拦截器功能类

  2. 配置拦截器的执行位置

  3. 声明拦截器的bean，并实现HandlerInterCeptor接口（注意：扫描加载bean）

    @Component
public class ProjectInterCeption implements HandlerInterceptor{
	public boolean preHandle(..) throws Exception{
		System.out.println("preHandle...");
		return true;
	}
	public void postHandle(..) throws Exception{
		System.out.println("postHandle...");
	}
	public void afterCompletion(..) throws Exception{
		Syetm.out.println("afterCompletion...");
	}
}

  4. 定义配置类，集成WebMvcConfigurationSupport,实现addInterceptor方法（注意：扫描加载配置）

    @Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport{
	@Override
	public void addInterceptors(InterceptorRegistry registry){
		...
	}
}

  5. 添加拦截器并设置拦截访问路径，路径可以通过可变参数设置多个

    @Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport{
	@Autowired
	private ProjectInterceptor projectInterceptor;
	
	@Override
	public void addInterCeptors(InterceptorRegisetry registry){
		regisyry.addInterceptor(proejectInterceptor).addPathPatternas("/books");
	}
}

  6. 使用标准接口WebMvcConfigurer简化开发（注意：侵入式较强）

    @Configuration
@ComponentScan("com.hcx.controller")
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer{
	@Autowired
	private ProjectInterCeptor projectInterceptor;
	
	public void addInterceptors(InterceptorRegistry registry){
		registry.addInterceptor(projectInterceptor).addPatternas("/books","/books");
	}
}

拦截器执行流程

  • preHandle
    • return true
      • contrller
      • postHandle
      • afterCompletion
    • return false
      • 结束

拦截器参数

  • 前置处理

     @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }

  • 具体参数：

    • handler：被调用的处理器对象，本质上是一个方法对象，对反射计数中的Method对象进行了再包装，可用于获取拦截方法信息

    • request：请求对象

    • response：响应对象

    • modelAndView:获取页面跳转相关数据

    • ex：拿到原始程序执行过程中出现的异常，表现层出现的异常

  • 返回值

    • 返回值未false，被拦截的处理器将不执行

多个拦截器执行顺序

  • 当配置多个拦截器是，形成拦截器链
  • 拦截器链的运行属性呢参照拦截器添加顺序未准
  • 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
  • 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作
总结：

  1. 拦截器链配置方式

  2. 拦截器链的运行顺序

    • preHandle:与配置顺序相同，必定运行【配置顺序就是运行顺序】
    • postHandle：与配置顺序相反，可能不运行【配置顺序就是运行顺序反过来】
    • afterComletion: 与配置顺序相反，可能不运行【配置顺序就是运行顺序反过来】

    解释：顺序情况下的话，走到哪里出现错误返回false，则后面的postHandle拦截器都不运行，afterComletion会运行

你可能感兴趣的:(笔记,ssm笔记,spring,maven,spring,boot)

  • 新网师的精神肤色（幕布笔记） 悦读书香
    王子老师的《极简100小妙招》收到已经几天了，之前大概的浏览了全书，今天起给自己定了一个计划，必须每天学习极简小妙招里面的一个妙招，并加以运用。一、今天要打卡什么内容因有完成每天学习极简小妙招的计划，所以今天晚饭吃的比较简单，草草吃完以后带着小宝到广场溜达一圈，急忙赶回来学习极简小妙招。再重看的时候不知道自己要学点什么，打卡哪一招，感觉哪个都简单，就看这一环节像王子老师说的“一看就会”，但做这一环
  • SpringMVC设置全局异常处理器 水岸齐天 javaspring
    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
  • C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
    C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • springboot集成logback-spring.xml文件 RT_0114 SpringBootspringbootspringlogback
    彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
  • 读书笔记《穿越寒冬》 如雪般飞舞
    各位好，我们今天来讲一本书，名字叫作《穿越寒冬》。看起来特别应景，大家觉得现在创业的状况不景气，大家都在忍受着寒冬的煎熬。但实际上，这本书的英文名字并不是这个意思，它的英文名叫作“如何创立一家新公司，并且能够活下来”。我在整个读完了以后，我发现这本书真正要翻译得好，它的名字应该叫作《创业生存手册》。这个书的作者，来自硅谷的霍夫曼船长。霍夫曼船长写过一本让创业者觉得特别贴心的书，叫作《让大象飞》它和
  • 2018-11-18成长小组学习笔记 实验中学45
    因为嗓子“罢工”，我面对众人只能借“微笑”代言。在开始授课前，绣霞老师先反馈上次作业的情况，提到“接纳”需是真正发自内心的完全接纳，而不是口头上的接纳，内心却是排斥的。提到一个“问题”孩子恰恰对家爱的更加“深沉”，夫妻间的问题不能影响到孩子，对孩子更好的爱不是你为他做的更多，而是给他自由、健康成长的空间。图片发自App一、孩子：家庭的一面镜子夫妻成了彼此的“投射”，婚姻便“吵的不可开交”，婚姻便成
  • 第一次用eclipse,导入项目错误Plug-in “org.eclipse.m2e.editor“ was unable to instantiate MavenPomEditor zhangfeng1133 eclipsejavaide
    第一次用eclipse,导入项目错误Plug-in"org.eclipse.m2e.editor"wasunabletoinstantiateMavenPomEditor。各种项目包，都不存在，maven应该能自动载入类包，比Php的composer方便太多Thecontainer'MavenDependencies'referencesnonexistinglibrary'C:\Users\Ad
  • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ideeclipsejava
    报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
  • 【鸿蒙HarmonyOS开发笔记】ArkUI常用组件介绍汇总（更新中） 温、 鸿蒙HarmonyOS开发笔记学习记录harmonyos笔记华为
    概述此文总结开发中用到的一些常用组件，便于查阅，此文持续更新，闲的没事就更线性布局（Row/Column）不多介绍了，最常用的布局组件，两者除了方向不一样，别的都一样方便起见下面只写Column常用属性排列方向上的间距：spaceColumn({space:20}){Row().width('90%').height(50).backgroundColor(0xF5DEB3)Row().width
  • 安卓笔记本 - Handler Message MessageQueue Looper SocialException
    不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
  • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
  • ruoyi使用笔记 万变不离其宗_8 项目笔记代码参考笔记笔记java前端
    1.限流处理@RateLimiter@PostMapping("/createOrder")@ApiOperation("创建充值订单")@RateLimiter(key=CacheConstants.REPEAT_SUBMIT_KEY,time=10,count=1,limitType=LimitType.IP)publicRcreateOrder(@RequestBodyFormform){/
  • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
  • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记 键盘上的五花肉 数据治理数据库数据仓库数据治理
    目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • 《老子》笔记19 2018-10-28 海上明月共
    第二十二章[原文]曲则全，枉则直，洼则盈，敝则新，少则得，多则惑。是以圣人抱一为天下式。不自见，故明；不自是，故彰，不自伐，故有功；不自矜，故长。夫唯不争，故天下莫能与之争。古之所谓"曲则全"者，岂虚言哉？诚全而归之。[译文]委曲便会保全，屈枉便会直伸；低洼便会充盈，陈旧便会更新；少取便会获得，贪多便会迷惑。所以有道的人坚守这一原则作为天下事理的范式，不自我表扬，反能显明；不自以为是，反能是非彰明
  • 以客户为中心的企业设计（咨询执业笔记） 觉者看世界
    以客户为中心的企业设计（咨询执业笔记）——何伏全案咨询知名专家数字经济大行其道，过剩的风险资本自由流动，股权市场日益强势，这些力量综合在一起，产生出诸多不合理的企业设计。这些事实使得企业设计的再创造越来越需要一种约束力，许多公司和投资者未能熟谙这种约束力，或者未能将其基本原理运用于具体的商业行为中，因此付出了沉重的代价。无利润区的确存在，并且已在全球蔓延，有愈演愈烈之势。它席卷了数以千计的公司，涉
  • Thinkphp - 详细实现网站系统登录功能，附带 Mysql 数据库设置、Web 前端展示界面、信息校验等（详细代码，即设计过程） 王佳斌 +Thinkphpmysql前端数据库
    前言登录功能，是我们几乎开发每个系统都必须的模块。登录功能设计思路，主要包括几个方面。用户输入网址展示登录页面用户输入用户名，密码等点击登录进行信息校验校验通过之后，记录用户登录信息，跳转指定页面用户校验失败，提示失败信息页面目录具体功能实现为了快速搭建可用、美观的页面，我们采用一个比较成熟的前端框架Bootstrap。下面我们到Bootstrap的官网Bootsrap官网下载bootstrap。
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • 程序员开发技术整理 laizhixue 学习前端框架
    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
  • 读书笔记|《穆斯林的葬礼》 飞舞的微辰
    她从来也没有打算对过去的恩怨进行报偿或是惩罚，只是想把该记住的都记住，该忘却的都忘却。事业的追求，并不一定要什么头衔和称号来满足，你爱上了一种东西，愿意用全部心血去研究它，掌握它，从中得到乐趣，并且永远也不舍得丢其它，这是事业心，是比什么都重要的......人生在世，谁也管不了谁；生儿育女，不是为了父母，是为了儿女自己，各人的路，让他们自己去闯吧。七尺之躯，一抔黄土，穆斯林们一个个都离去了，什么都
  • C#学习笔记 2301_79022588 学习笔记
    一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
  • SAP Spartacus的Component映射 JerryWang_汪子熙
    Spartacus默认的购物车界面：https://github.com/SAP/spartacus-bootcamp/blob/master/sparta0/src/app/components/cart.component.ts新建一个CartComponent，对Spartacus标准的CartDetailsComponent进行扩展：import{Component}from'@angul
  • 遇见美好｜期待越来越好的自己｜复盘日记Day137 沫ma的1001页
    遇见美好｜期待越来越好的自己｜复盘日记Day1372021年7月21日星期三晴喜马拉雅(沫沫成长记）亲子共读：Day42阅读学习践行Day.17/21晨间日记Day.17/21昨日晚安：23:02今日早安：05:00早起：Day806❥今日运动｜跑步0Km（未完成）❥今日自我成长｜学习新知识1.听书＋书写笔记,小花生阅读打卡2..阅读学习，听音频＋写作业3.时间管理2.0线上践行，听课+写作业4.
  • D43+1组棉布+《一个人的朝圣》读书笔记 棉布家的小橘子
    前几天读了《一个人的朝圣》，感受到信念、目标对一个人是多么重要。哈罗德因为奎妮的一封告别信，步行横跨英格兰去探望她。因为有了目标和信念他才能坚持下去。而奎妮也一直在等他。一路哈罗德回忆儿子戴维，回忆自己小时候的遭遇，回忆与妻子莫琳的种种。想通了许多事情，与其说他要去拯救奎妮不如说在拯救自己。哈罗德与父母哈罗德的童年是不幸的，爸爸妈妈根本没有想当父母却生下了他。妈妈离家出走，爸爸开始找不同的阿姨，在
  • Java学习笔记04：Java_数组 JasonYangQ Javajava
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
  • Websocket服务监听收发消息 beiback Java服务器问题websocket网络协议网络
    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java 计算机程序老哥
    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
  • JavaScript快速入门笔记之二（变量、常量、数据类型） eshineLau 前端开发javascript笔记前端
    JavaScript快速入门笔记之二（变量、常量、数据类型）1、变量何时使用变量：程序中的一切数据都要保存在变量中，反复使用如何使用变量：2种情况：赋值和取值赋值：2步：1.1创建变量：——声明——创建一个新的空变量语法：var变量名;强调：仅声明，未赋值的变量，默认值是undefined命名：1.不能以数字开头2.不能用保留字。3.一般采用驼峰命名1.2赋值：将数据保存到变量中语法：变量名=数据
  • 对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
  • android 网络 百合不是茶 网络
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat   服务器代码;  servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
  • [读书笔记]读法拉第传 comsci 读书笔记
          1831年的时候,一年可以赚到1000英镑的人..应该很少的...       要成为一个科学家,没有足够的资金支持,很多实验都无法完成       但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
  • 随机数的产生 沐刃青蛟 随机数
    c++中阐述随机数的方法有两种：   一是产生假随机数（不管操作多少次，所产生的数都不会改变）          这类随机数是使用了默认的种子值产生的，所以每次都是一样的。   //默认种子 for (int i = 0; i < 5; i++) { cout<<
  • PHP检测函数所在的文件名 IT独行者 PHP函数
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 代码：   [php]   view plain copy // Filename: functions.php    <?php&nbs
  • 银行各系统功能简介 文强chu 金融
    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
  • Python学习1(pip django 安装以及第一个project) 小桔子 pythondjangopip
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
  • php 数组 aichenglong PHP排序数组循环多维数组
    1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
  • 安装python2.7 AILIKES python
    安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp  /opt/soft/Python-2
  • java异常的处理探讨 百合不是茶 JAVA异常
    //java异常  /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常  b,抛出异常  c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常   */   //2，学会使用try-catch-finally来处理异常  
  • getElementsByName实例 bijian1013 element
    实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
  • 探索JUnit4扩展：Runner bijian1013 java单元测试JUnit
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。         文章地址：http://www.blogjava.net/jiangshachina/archive/20
  • [MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
    1. 副本集的特性   1)一台主服务器(Primary),多台从服务器(Secondary)   2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作   3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来   2
  • 【Spark八十一】Hive in the spark assembly bit1129 assembly
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
  • Nginx问题定位之监控进程异常退出 ronin47
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
  • No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
    方法一：常用方法   关闭XML验证 工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 方法二：（个人推荐） 添加 内容如下 <?xml version=
  • Netty源码学习-DefaultChannelPipeline bylijinnan netty
    package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
  • MYSQL数据库常用备份及恢复语句 chicony mysql
    备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
  • 小白谈谈云计算--基于Google三大论文 CrazyMizzz Google云计算GFS
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。     我先说说GFS   &n
  • hadoop 平衡空间设置方法 daizj hadoopbalancer
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property>   <name>dfs.balance.bandwidthPerSec</name>     <value>10485760</value>     <description&g
  • Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
  • Android学习之路 dcj3sjt126com Android学习
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 下面说说我学习Android的感受，我学Android首先是看MARS的视
  • java 遍历Map的四种方法 eksliang javaHashMapjava 遍历Map的四种方法
    转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
  • 【精典】数据库相关相关 gengzg 数据库
    package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
  • 自动补全 huyana_town 自动补全
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
  • jquery在线预览PDF文件，打开PDF文件 天梯梦 jquery
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。   核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
  • ViewPager刷新单个页面的方法 lovelease androidviewpagertag刷新
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
  • 利用按位取反（~）从复合枚举值里清除枚举值 草料场 enum
    以 C# 中的 System.Drawing.FontStyle 为例。   如果需要同时有多种效果， 如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline;   如果需要去除 style 里的某一种效果，
  • Linux系统新手学习的11点建议 刘星宇 编程工作linux脚本
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
  • hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAOHibernate
    /** * <p>方法描述:sql语句查询 返回List<Class> </p> * <p>方法备注: Class 只能是自定义类 </p> * @param calzz * @param sql * @return * <p>创建人：王川</p> * <p>创建时间：Jul
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他