spring

 <dependencies><!--spring的核心依赖jar包--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><!--日志相关--><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.12</version></dependency><!--有单元测试的环境，Spring5版本，Junit4.12版本--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!--连接池  阿里巴巴  第三方--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.10</version></dependency><!--mysql驱动包--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.6</version></dependency><!--Spring整合Junit测试的jar包--><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.2.RELEASE</version><scope>test</scope></dependency></dependencies>

serialVersionUID：

这是一个特殊的字段名称，用于标识类的序列化版本。当一个类实现了 Serializable 接口后，在进行对象的序列化和反序列化操作时，Java 会使用这个版本号来确保序列化和反序列化的对象是来自同一个类的兼容版本。如果在反序列化时发现类的 serialVersionUID 与序列化时的不一致，会抛出 InvalidClassException 异常。

IOC（控制反转）:将创建对象的权力交给spring

实例化Bean对象的方式：

①创建applicationContext.xml文件配置bean管理

<!--IOC 管理 bean-->
<bean id="userService" class="com.qcbyjy.service.UserServiceImpl"
/>

②静态工厂实例化方式

③动态工厂实例化方式

④半注解方式

在applicationContext.xml里开启注解扫描

<!--开启注解扫描 com.qcbyjy.所有的包中的所有的类 -->
<context:component-scan base-package="com.qcbyjy" />

⑤纯注解方式

编写配置类替换掉xml配置文件

DI依赖注入

注入值的三种方式：

①属性的set方法注入值

②属性构造方法方式注入值

③注解的方式

可以在xml文件里开启注解扫描（半注解方式），也可以用配置类替换掉配置文件（纯注解方式）

spring框架整合junit单元测试

不用注解：

有配置文件：

//配置文件
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--整合单元测试--><bean id="c" class="com.qcbyjy.demo5.Car"/>
</beans>//测试类
public class Demo3 {@Testpublic void run1(){// 工厂ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_anno.xml");// 获取对象Car car = (Car) ac.getBean("c");System.out.println(car);}
}

纯注解形式---配置类：

//配置类
// 声明当前类是配置类
@Configuration
// 扫描指定的包结构
@ComponentScan(value = "com.qcbyjy.demo4")
public class SpringConfig {
}//测试类
public class Demo4 {/*** 编写程序，需要加载配置类*/@Testpublic void run1(){// 创建工厂，加载配置类ApplicationContext ac = newAnnotationConfigApplicationContext(SpringConfig.class);// 获取到对象Order order = (Order) ac.getBean("order");System.out.println(order);}
}

注解形式

有配置文件：

//配置文件
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--整合单元测试--><bean id="user" class="com.qcbyjy.demo5.User"/>
</beans>//配置类：Spring 整合 Junit 单元测试
@RunWith(value = SpringJUnit4ClassRunner.class) 
// 运行单元测试
@ContextConfiguration(value ="classpath:applicationContext_test.xml") 
// 加载类路径下的配置文件
public class Demo5 {// 测试哪一个对象，把该对象注入进来，在测试环境下，可以使用注解的方式注入测试的对象// 按类型自动注入@Autowiredprivate User user;@Testpublic void run1(){// 创建工厂，加载配置文件......// 调用对象的方法user.sayHello();}
}

配置类--纯注解形式

//配置类
// 声明
@Configuration
// 扫描包结构
@ComponentScan(value = "com.qcbyjy.demo6")
public class SpringConfig6 {
}//测试类：Spring 整合 Junit 注解的方式测试
@RunWith(SpringJUnit4ClassRunner.class)
// 加载配置类
@ContextConfiguration(classes = SpringConfig6.class)
public class Demo6 {// 按类型注入@Autowiredprivate Customer customer;/*** 测试*/@Testpublic void run1(){customer.save();}
}

多配置文件加载方式

多配置类

JDBC执行流程

把相同的127提取出来，形成 工具类：

1.0版本

//工具类
package com.qcby.utils;
import com.mysql.jdbc.Driver;
import java.sql.*;
public class JdbcUtils {//1.加载驱动public static void createDriver(){try {//两种  1.直接调用方法DriverManager.registerDriver(new Driver());//2.反射加载//Class.forName("com.mysql.jdbc.Driver");} catch (Exception e) {e.printStackTrace();}}//2.获取连接public static Connection getConnection() {Connection connection = null;try {//加载驱动createDriver();//获取连接connection = DriverManager.getConnection("jdbc:mysql:///spring_db", "root", "root");} catch (SQLException e) {e.printStackTrace();}return connection;}//7.关闭资源（查询） 重载public static void close(Connection connection, Statement statement, ResultSet resultSet){try {resultSet.close();statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}//7.关闭资源（增删改） 重载public static void close(Connection connection, Statement statement){try {statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}}

//查找的方法
public void select(){Connection connection = null;Statement statement = null;ResultSet resultSet = null;try {//jdbc连接数据库//1.加载驱动//2.建立连接connection = JdbcUtils.getConnection();//3.编写sqlString sql = "select * from account";//4.获得执行sql的stmt对象//两个 stmt（sql注入问题） pstmt（预编译 防止sql植入问题 占位符）statement = connection.createStatement();//5.运行sql 得到结果集resultSet = statement.executeQuery(sql);//6.遍历结果集while(resultSet.next()){Account account = new Account();account.setId(resultSet.getInt("id"));account.setName(resultSet.getString("name"));account.setMoney(resultSet.getDouble("money"));System.out.println(account);}} catch (SQLException e) {e.printStackTrace();}finally {//7.释放资源（先开的后关 后开的先关）JdbcUtils.close(connection,statement,resultSet);}
}

2.0版本

把可以变的提取到 db.properties(k,v形式)，把死的变成活的

以后用外面的文件形成映射，改变外面的这个文件也就改变了，不用停止服务

工具类把需要变的写到 static静态代码块里面

具体的方法不变

//工具类
package com.qcby.utils;import com.mysql.jdbc.Driver;import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;public class JdbcUtils {private static final String driverclass;private static final String url;private static final String username;private static final String password;//静态代码块  类一加载的时候就会执行 调用这个类的啥时候static {//加载db.properties文件读取连接数据库的所有参数//加载属性文件Properties pro = new Properties();InputStream inputStream = JdbcUtils.class.getResourceAsStream("/db.properties");try {pro.load(inputStream);} catch (IOException e) {e.printStackTrace();}//给常量赋值driverclass = pro.getProperty("driverclass");url = pro.getProperty("url");username = pro.getProperty("username");password = pro.getProperty("password");}//1.加载驱动public static void createDriver(){try {//两种  1.直接调用方法//DriverManager.registerDriver(new Driver());//2.反射加载Class.forName(driverclass);} catch (Exception e) {e.printStackTrace();}}//2.获取连接public static Connection getConnection() {Connection connection = null;try {//加载驱动createDriver();//获取连接connection = DriverManager.getConnection(url,username,password);} catch (SQLException e) {e.printStackTrace();}return connection;}//7.关闭资源（查询） 重载public static void close(Connection connection, Statement statement, ResultSet resultSet){try {resultSet.close();statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}//7.关闭资源（增删改） 重载public static void close(Connection connection, Statement statement){try {statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}}

连接池

多个操作，创建销毁连接时间会很长，性能会降低。

所以需要连接池（池化思想）：销毁变成归还，再来几个人，不需要再创建了，能得到复用，减少了创建连接和销毁连接的时间。（开锁：一共五把钥匙，走了就留下给下一个人用，等待一些时间之后五个人都没有归还，就创建新的，小于最大限制就行）

3.0版本

package com.qcby.utils;import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;public class JdbcUtils3 {//连接池对象private static DataSource ds;static {//加载属性文件Properties properties = new Properties();InputStream inputStream = JdbcUtils3.class.getResourceAsStream("/druid.properties");try {//加载属性文件properties.load(inputStream);//创建连接池对象//Druid 会根据 url 参数自动选择合适的驱动ds = DruidDataSourceFactory.createDataSource(properties);} catch (Exception e) {e.printStackTrace();}}//创建连接public static Connection getConnection(){Connection conn = null;try {conn = ds.getConnection();} catch (SQLException e) {e.printStackTrace();}return conn;}//7.关闭资源（查询） 重载public static void close(Connection connection, Statement statement, ResultSet resultSet){try {resultSet.close();statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}//7.关闭资源（增删改） 重载public static void close(Connection connection, Statement statement){try {statement.close();connection.close();} catch (Exception e) {e.printStackTrace();}}
}

代理

静态代理基于继承实现

动态代理是基于接口实现

事务：

客户端验证：两种方式

默认是自动提交，回滚之后就自动提交了，事务结束了（提交是事务结束，回滚也是事务结束，提交之后也不能回滚了）
不自动提交：只要不提交，这个事务就不结束，回滚之后还能进行回滚，关闭窗口就是关闭事务了（设置的关闭自动提交也失效了）。

命令

查看该数据库下的所有的表：show tables;

开启事务：start transaction;

可以输入sql语句（需要加;）

关闭自动提交：set autocommit = off/0;（开启事务之后设置才有效）

提交：commit;

回滚：rollback;

JDBC验证

只有一种：将自动提交关闭

public static void main(String[] args) {Connection connection = null;Statement statement = null;ResultSet resultSet = null;try {//jdbc连接数据库//1.加载驱动//2.建立连接connection = JdbcUtils3.getConnection();//3.编写sqlString sql = "update account set money = money-10 where name = 'aaa'";String sql2 = "update account set money = money+10 where name = 'bbb'";//4.获得执行sql的stmt对象//两个 stmt（sql注入问题） pstmt（预编译 防止sql植入问题 占位符）statement = connection.createStatement();//开启事务（关闭自动提交）connection.setAutoCommit(false);//5.运行sql 得到结果集
//            resultSet = statement.executeQuery(sql);int i = statement.executeUpdate(sql);//int j = 10/0;int i2 = statement.executeUpdate(sql2);//事务提交connection.commit();} catch (Exception e) {e.printStackTrace();//事物的回滚try {connection.rollback();} catch (SQLException e1) {e1.printStackTrace();}}finally {//7.释放资源（先开的后关 后开的先关）JdbcUtils.close(connection,statement);}}

不考虑事物的隔离性会引发的问题