【2020Spring编程实战笔记】Spring开发分享~

Spring开发笔记【CodeLinghu】

文章目录

• ​​Spring开发笔记【CodeLinghu】​​
• ​​00、spring框架绪论​​
• ​​01、spring环境搭建​​

• ​​1.01spring依赖的导入​​
• ​​1.02生成spring框架的配置文件​​
• ​​1.03spring框架如何管理组件对象的创建​​
• ​​1.04启动工厂并在工厂中启动组件对象​​

• ​​02、IOC和DI核心思想​​

• ​​2.1、IOC 控制反转 核心思想定义​​
• ​​2.2、面试小概念：​​

• ​​03、set注入的语法​​
• ​​04、构造注入(用的不多，只做了解)​​
• ​​05、自动注入(用的也不多)​​
• ​​06、spring工厂的细节​​
• ​​07、AOP面向切面编程​​

• ​​7.1、静态代理(proxy)​​
• ​​7.2、动态代理​​
• ​​7.3、面向切面编程AOP原理概念​​
• ​​7.4、AOP编程的编程步骤​​

• ​​7.4.1引入AOP编程相关的依赖​​
• ​​7.4.2开发项目额外功能通知​​
• ​​7.4.3配置切面spring.xml​​

• ​​7.5、aop编程之环绕通知​​
• ​​7.6、切入点表达式​​

• ​​08、IOC和AOP的复习​​
• ​​09、spring创建复杂对象​​
• ​​10、spring整合mybatis思路分析​​

• ​​10.1、引入依赖​​
• ​​**整合spring和mybatis新方法**：​​
• ​​10.2、spring整合mybatis编程步骤​​

• ​​10.2.1引入依赖​​
• ​​10.2.2配置spring.xml​​
• ​​10.2.3从工厂中获取SqlSessionFactory对象​​

• ​​11、spring整合mybatis DAO层的编程开发​​
• ​​12、spring注解式开发​​
• ​​13、ssm整合注解式开发​​
• ​​14、log4j的使用​​
• ​​15、事务传播属性【面试会用】​​
• ​​15、事务传播属性【面试会用】​​

00、spring框架绪论

曾经做开发的时候，我们用的框架比如 ​​Struts2​​​ ​​Mybatis​​​开发一个应用，用的非常单一，两者没有联系是独立起来的，现在学习 ​​spring​​​框架可以做到 ​​Struts2​​​+ ​​spring​​​+ ​​mybatis​​中间的桥梁，进行整合联系糅合。我们把这个特点称为 轻量级解决方案。

• **特点：**将项目中的单层框架以最佳方式融合在一起。其实就是上述的。
• 核心作用：

01、spring环境搭建

1.01spring依赖的导入

• 我们不用spring最新版本，因为对jdk要求太高，我们选择spring 4.x版本即可。
• 进入​​maven​​管理，搜索spring。

网址：https://mvnrepository.com/search?q=spring

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>

1.02生成spring框架的配置文件

1.03spring框架如何管理组件对象的创建

• 看一下我们传统的对象是通过​​new​​ 出来的：

接下来我们要用​​bean​​​来管理对象​​userDao​​。

<!--
        1、bean作用：用来管理组件对象的标签。
        2、用来管理组件java类的全类名
        3、在工厂中生成组件对象的唯一标识
    -->
    <bean id="bb" class="day1.UserDaoImpl"/>

1.04启动工厂并在工厂中启动组件对象

package day1;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    public static void main(String[] args) {
        //启动工厂
        ApplicationContext context=new ClassPathXmlApplicationContext("day1/day1.xml");

        //获取工厂中的对象,还要进行强制转换一下
        UserDao userDao = (UserDao) context.getBean("bb");

        //使用对象
        userDao.find("小明");
    }

}

02、IOC和DI核心思想

2.1、IOC 控制反转 核心思想定义

• IOC全称：invasion of controll翻译反转控制，控制反转。

以前做开发我们是手动​​new​​​对象，我们想在哪个类创建对象就创建对象，主动权在我们手上，​​spring​​的核心就是：将我们的这个主动权剥夺了，我们创建对象的权利移交给了spring工厂，创建之前要通过 spring工厂来创建，相当于 权力下放。

• DI全称：dependcy injection翻译为依赖注入

2.2、面试小概念：

03、set注入的语法

• 一个依赖注入的实例：

项目结构图：

一个接口，一个实现类，一个测试类,xml配置文件。

studentImpl类：

package pojo;

public class StudentImpl {
    private String name;// 1、把依赖生成成员变量

    public void setName(String name) {// 2、生成一个set方法准备导入依赖
        this.name = name;
    }

    @Override
    public String toString() {
        return "StudentImpl{" +
                "name='" + name + '\'' +
                '}';
    }
}

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="student" class="pojo.StudentImpl">
        <property name="name" value="令狐"/>生成对象，并赋值，就是依赖注入！
    </bean>
</beans>

测试类：

package pojo;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StudentTest {
    public static void main(String[] args) {
        //启动指定的工厂
       ApplicationContext Context = new ClassPathXmlApplicationContext("/init/init.xml");
        //拿取指定的对象
        StudentImpl student = (StudentImpl) Context.getBean("student");
        //打印返回
        System.out.println(student.toString());
    }
}

04、构造注入(用的不多，只做了解)

• 将需要注入的对象声明为成员变量

package construct;

public class Car {
    private String brand;
    private String corp;
    private Double price;
    private int maxSpeed;
}

• 利用构造函数，我写了两个：

package construct;

public class Car {
    public Car(String brand, String corp, Double price) {
        this.brand = brand;
        this.corp = corp;
        this.price = price;
    }
    public Car(String brand, String corp, int maxSpeed) {
        this.brand = brand;
        this.corp = corp;
        this.maxSpeed = maxSpeed;
    }
}

• 工厂容器里边配置一下：

<?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="car" class="construct.Car">
        <constructor-arg value="Audi" type="java.lang.String"/>
        <constructor-arg value="luntai" type="java.lang.String"/>
        <constructor-arg value="30" type="java.lang.Double"/>
    </bean>
    <bean id="car1" class="construct.Car">
        <constructor-arg value="Audi" type="java.lang.String"/>
        <constructor-arg value="luntai" type="java.lang.String"/>
        <constructor-arg value="300" type="int"/>
    </bean>
</beans>

• 构造注入的测试

package construct;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class CarTest {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("/init/init.xml");
        Car car = (Car) Context.getBean("car");
        System.out.println(car.toString());
    }
}

• 执行：

05、自动注入(用的也不多)

package autodi;

public class BookDAOImpl implements BookDAO {
    private BookDAO bookDAO;

    @Override
    public void save() {
        System.out.println("BookDAO invoke~~~");
    }
}

<?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="bookDAO" class="autodi.BookDAOImpl"/>

    <!--
        autowrite的作用：用来指定当前组件中依赖的组件的注入方式是什么
        注意：类中成员变量与工厂中bean的id一致则自动赋值，否则不注入
        byname:根据类中的成员变量名进行注入
        bytype:根据类中的成员变量类型进行注入
    -->
    <!--<bean id="bookService" class="autodi.BookServiceImpl" autowire="byName"/>-->
    <!--
        类中成员变量的类型与工厂中bean的类型一致则强行注入，否则不注入。
    -->
    <bean id="bookService" class="autodi.BookServiceImpl" autowire="byType"/>
</beans>

06、spring工厂的细节

07、AOP面向切面编程

7.1、静态代理(proxy)

• 给一幅图做一个简单介绍：

7.2、动态代理

7.3、面向切面编程AOP原理概念

7.4、AOP编程的编程步骤

7.4.1引入AOP编程相关的依赖

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
  </dependencies>

7.4.2开发项目额外功能通知

7.4.3配置切面spring.xml

7.5、aop编程之环绕通知

7.6、切入点表达式

• 切到某个类，就会为这个类创建 动态代理对象。
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OkWIylWL-1604738928148)(https://img.rruu.net/image/5fa0a90a1676a)]

08、IOC和AOP的复习

09、spring创建复杂对象

除了我们之前学过的new简单对象，其实还有很多对象是不能new出来的，比如抽象类对象，我们需要用官方提供的方法来对它进行实例化，然后调用实现功能。

对于复杂对象，我们不能交给工厂处理，也不能new处理。那么该如何创建这些复杂对象呢？

10、spring整合mybatis思路分析

10.1、引入依赖

首先引入两个重要依赖：

• ​​mysql​​
• ​​mybatis​​

<!--引入mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>

    <!--引入mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.4</version>
    </dependency>
  </dependencies>

• ​​mybatis​​官方：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.4</version>
</dependency>

整合spring和mybatis新方法：

10.2、spring整合mybatis编程步骤

10.2.1引入依赖

• ​​spring​​
• ​​mybatis​​
• ​​mysql​​
• ​​mybatis-spring​​
• ​​Druid​​

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.20.RELEASE</version>
    </dependency>

    <!--引入mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>

    <!--引入mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.4</version>
    </dependency>

    <!--引入mybatis-spring-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.4</version>
    </dependency>

    <!--引入Druid依赖-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.19</version>
    </dependency>
  </dependencies>

10.2.2配置spring.xml

10.2.3从工厂中获取SqlSessionFactory对象

11、spring整合mybatis DAO层的编程开发

12、spring注解式开发

13、ssm整合注解式开发

14、log4j的使用

其实就是在运行项目的时候，控制台会打印很多日志信息，我们可以选择监听某些类的日志打印信息，也可以屏蔽不想看到的日志信息。

• 引入依赖：

<!--log4j的依赖-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.10.0</version>
    </dependency>
    <!--log4j12的依赖-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
      <scope>test</scope>
    </dependency>

• ​​log4j​​配置模板：

Iog4j.rootLogger =ERROR,bb
1og4j.appender.bb =org.apache.1og4j.ConsoleAppender
1og4j.appender.bb.layout=org.apache.log4j.PatternLayout
log4j.appender.bb.layout.conversion=[%p] %d{yyyy-MM-dd-} %m%n
1og4j.logger.com.linghu.dao=DEBUG
1og4j.logger.org.spring framework=DEBUG

15、事务传播属性【面试会用】

rsion>2.10.0



org.slf4j
slf4j-log4j12
1.7.25
test

- `log4j`配置模板：

```xml
Iog4j.rootLogger =ERROR,bb
1og4j.appender.bb =org.apache.1og4j.ConsoleAppender
1og4j.appender.bb.layout=org.apache.log4j.PatternLayout
log4j.appender.bb.layout.conversion=[%p] %d{yyyy-MM-dd-} %m%n
1og4j.logger.com.linghu.dao=DEBUG
1og4j.logger.org.spring framework=DEBUG

• [外链图片转存中…(img-grxBafms-1604738928182)]
• [外链图片转存中…(img-BTyrPftI-1604738928184)]

15、事务传播属性【面试会用】