[Java知识库]Spring内涵

Spring:

spring依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Spring9_6SpringProjectFirst</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
<!--        SpringIoc(Start)-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
<!--        SpringIOC(End)-->
<!--        SpringAop(Start)-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
<!--SpringAop(End)-->
<!--        SpringMybatis(Start)-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>
<!--        数据库连接工具-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
<!--        SpringMybatis(End)-->
<!--        SpringMvc(Start)-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
<!--        SpringMvc(End)-->
    </dependencies>


</project>

Ioc

解耦：当我们持久化Dao的时候，我们按传统的创建对象形式在服务层Service中创建我们是不是要new UserDao(),如果我们使用loc container，把控制权交给应用程序去控制，我们只要使用DI(依赖注入)就可以直接使用。
Bean:就是被private加上set/get方法修饰的Pojo实体类
loc（控制反转）:这些Bean的创建工作，即由用户管理Bean转变为框架管理Bean，这个就叫控制反转 - Inversion of Control (IoC)。
如果我们没使用loc，那么我们将自己把Bean添加到容器中
实体类：

采用xml的方式把实体类添加到容器中（xml，java->configuration,注解）：

通过ClassPathXmlApplicationContext来初始化容器对象，并通过getBean来获取到该Bean对象，通过对象来调用方法。

有了Spring框架，可以将原有Bean的创建工作转给框架, 需要用时从Bean的容器中获取即可，这样便简化了开发工作。
DI注入：
我们可以在使用Springconfig的xml，通过set方法,构造器和p空间来注入到Bean中。

Aop（切面编程），其实就是把aspect框架的一部分分解了下来了，添加到spring中命名为AOP,也就是添加配置，在一个类中的方法中在前面后面添加新的方法before(之前)after(之后),
操作步骤：
1：使用Springconfig的xml把要插入的bean通过xml生成一个Bean添加到Ioc容器中，并通过

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<bean classs="com.SpringAop.TestStudent.Student" id="Student"></bean> 要被切入的实体类
<bean class="com.SpringAop.TestAop.TestAop" id="TestAop"></bean>   要插入方法的实体类
<aop:config>
<aop:pointcut  id="Student1" expression="exectuion(* com.SpringAop.TestStudent.Student.show(String))"></aop:pointcut> *表示该方法的返回值 切入源
	<aop:aspect>      切入的方法
			<aop:before method="before" pointcut-ref="Student1"></aop:before>
			<aop:after methode="after" poincut:ref="Student1"></aop:after>
	</aop:aspect>
</aop:config>

Student实体类：

要切入的方法：
main方法：mybatis:
xml中创建数据库连接参数：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<Configurtion>
<environments default="development">
	<environment id="development"></environment>
</environments>
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POLED">
<property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
</dataSource>
</Configurtion>

我们用配置类来连接数据库：
Spring-Mybatis中已经对我们的连接进行了操作，所以我们只需要返回一个SqlSessionTemplate

package com.SpringMybatis.Utility;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configurtion
@MapperScan(basePackages="com.SpringMybatis.Mapper")   //扫描mapper接口
public class JdbcUtility {
    @Bean
    public SqlSessionTemplate JdbcTemplate() throws Exception{
        SqlSessionFactory sqlbuild = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-configuration.xml"));//获取xml中配置的sql连接参数
        return new SqlSessionTemplate(sqlbuild);
    }
    }

添加Mapper接口：

@Mapper
public interface TestMapper{
	   @Select("select * from test1 where t2=1") //通过注解传递sql语句
    List<Student> getname();
}

实体类：

package com.SpringMybatis.POJO;

import java.io.Serializable;

public class Student implements Serializable {
    private String username;
    private String password;
    private  int age;
    private  int t2;

    public String getUsername() {
        return username;
    }

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", t2=" + t2 +
                '}';
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getT2() {
        return t2;
    }

    public void setT2(int t2) {
        this.t2 = t2;
    }

    public Student(String username, String password, int age, int t2) {
        this.username = username;
        this.password = password;
        this.age = age;
        this.t2 = t2;
    }

    public Student() {
    }
}

在main中执行程序：

public static void main(String[] args){
	AnnotationConfiglicationContext context=new AnnotationConfiglicationContext(JdbcUtility .class);
	TestMapper  mapper=context.getBean(TestMapper.class);
	List<Student> list=mapper.getname();
	System.out.println(list);
}

Mysql事物：

mysql：
第一范式：列不可分解
第二范式：唯一标识
第三范式：引用主键
事物的特性：
原子性：事物代码要么都会被运行，要么都不会被运行
一致性：事物的状态都是一样的
隔离性：事物和其他事物之间是隔离开来的
持久性：表示事物提交后，无论系统发生什么错误，数据都不会变
事物的隔离级别：
读未提交：事物还没有提交，而其他事物会读取该事务没有提交的缓存的数据，这就是**脏读**

读已提交：就是只能读已经提交了的数据。事件A读取初始数据，在这个间隔中事件B也开始读取了初始数据，事件A对初始数据进行了操作，但是还没有提交，因此事物B是获取不到事件A操作后的数据，导致事件B还是查询的是初始数据，所以当事件A和事件B读取出来的数据就会不一样，这就造成了**虚读**。

可重复读：这是Mysql的事物隔离级别，就是在A事物读取的时候，B事物也去读取，但是B事物并不能对数据进行更新，但是可重复读，有个问题就是，只是禁用了update操作，并没有禁用insert，所以这就会造成**幻读**

串行化：事物的每一次读取都要等待前一个事物的结束才会执行，会导致效率低