1.Spring ioc的概念：
spring ioc 就是一种把对象的控制权、管理权交给spring 容器的方法。这种方法的实现可以将对象和对象进行解耦。
1.1.Spring ioc的实现原理：
实现的主要步骤就是：xml文件解析 、工厂设计模式 、反射。伪代码如下：
#service层
public void service (){
excute(){}
}
#dao层
public void dao(){
add(){}
}
#1.原生方法就是：
#service调用dao 直接new一个dao对象
excute（）{
dao dao = new dao();
dao.add();
}
#2.现在使用ioc实现对象之间的调用：使用的技术xml文件解析、工厂设计模式、反射
#伪代码如下
public static dao factory (){
String lujing= classvalue #xml文件解析路径
Class clazz=clazz.forName(lujing); //反射，通过包路径解析出类类型
return (dao)clazz.newInstence(); //通过类类型返回工厂对象
}
#总结：本质上ioc容器就是一个工厂类，但这个工厂类同时包含了很多功能，去实现，对象之间的解耦。
?1.2.springioc的使用：
????????1.2.1：xml文件实现：
? ? ? ? ? ? ? ? （1）xml文件实现对象的创建：
1.首先在类的基础之上加上spring注解（component、controller、service、respository）
2.在bean.xml文件里面配置bean的基本信息、扫描包信息
3.获取bean的时候使用ClassPathXmlApplicationContext("bean.xml")去获取配置文件的信息、用context.getbean去获取bean对象实例。
? ? ? ? ? ? ? ? （2）xml文件实现值的注入：
1.根据上述创建bean对象，第二步配置bean的基本信息的基础之上，
<bean name="" class ="com.hzk">
<property name="" value =""></property>//再去配置成员变量值的注入
????????1.2.2：注解方式实现：
? ? ? ? ? ? ? ? （1）注解实现对象的创建：
1.在类的头顶加上注解（@Component @Service @Controller @Repository）
2.配置SpringConfig类@Configuration注解该类@ComponentScan（"com.hzk"）配置扫描路径
3.获取bean的时候使用AnnotationConfigApplicationContext(SpringConfig.class)获取配置
4.context.getbean去获取bean的对象
????????????????（2）注解实现值的注入：
在变量的头顶注释
@Value（"值"）
?????????????
2.spring aop的概念：
spring aop是一种设计思想，也就是把需要用代码添加的一些逻辑代码独立的分割到配置文件，需要使用的时候直接切入代码中。
????????2.1.aop的原理 ：
????????spring aop 基于动态代理的方法进行实现，接口的代理使用就是jdk动态代理（idk proxy）、
????????普通类的代理使用的就是cglib。
????????2.1.1jdk动态代理的伪代码实现如下：
public interface a(){
add();
}
public class b implements a(){
add(){
System.out.println("实现类输出");
}
}
//jdkProxy动态代理实现
main{
//三个参数：1.类加载器 2.类类型数组 3.增强类（重写后的）
class[] clazz = {b.class};
Proxy.newProxyInstence(b.class.getClassloader(),clazz,new zengqiang());
}
class zengqiang implements ivationHandler(){
private Object object;
public zengqiang(Object object){
this.object=object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
//写增强逻辑
Object invoke = method.invoke(object, args);
return invoke;
}
}
? ?2.2 .AspectJ实现aop动态代理的实现：
? ? ? ? ? ? ? ?2.2.1.基于注解实现动态代理
1.引入AspectJ和spring aop的依赖
2.在xml文件里面配置包扫描、配置头部文件引入aop和context
3.在需要增强的类和增强类上注释（@Component@Serivce@Controller@Respository）、并在增强类上注释@Aspect标识这是一个增强类
4.在增强类的增强方法上注释增强的逻辑（@Before@After@AfterThrowing@AfterReturning@Around）
4.在xml文件里面引入aspectj自动创建代理对象，再把普通类的bean注册进容器中
? ? ? ?????????2.2.2.基于xml文件实现动态代理
现在已经不怎么使用这种方式实现了。
配置文件这样配置：aop的切入点和增强逻辑
<bean name="Users" class="com.aopanno.Users"/>
<bean name="userProxy" class="com.aopanno.userProxy"/>
<aop:config>
<aop:pointcut id="User" expression="execution(* com.aopanno.Users.add(..))"/>
<aop:aspect ref="userProxy" >
<aop:after method="userproxy" pointcut-ref="User"/>
</aop:aspect>
</aop:config>
????????2.3.spring整合jdbc实现对数据库的操作
1.引入相关依赖mysqlconnect、spring-jdbc...
2.bean.xml文件中配置数据库连接池，同时配置jdbcTemple转载进bean的容器中
<!--数据库连接池（druid）-->
<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="url" value="jdbc:mysql://192.168.13.128:3306/jdbcTemple?useUnicode=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
</bean>
<!--将jdbc也配置进spring中去，参数datasource也配置进去-->
<bean name="jdbcTemple" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
?3.需要操作数据库的地方导入jdbcTemple使用的是@Autowired注解自动注入bean中配置好的jdbcTemple
4.jdbcTemple里面的api可以对数据库进行操作。
public class mapperimpl implements mapper {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void mapper_sout(){
jdbcTemplate.update("insert into users values (?,?,?) ","黄文鸿",18,1);
System.out.println("我是mapper层的输出！！！");
}
}
? ? ? ? ? 2.4.spring事务：
? ? ? ? ? ? ? ? ? ? ? ? 2.4.1.事务的基本概念：
事务时数据库操作最基本的单元。就是逻辑上的一组操作，要么都成功、要么都失败。
? ? ? ? ? ? ? ? ? ? ? ? 2.4.2.事务的特性：
（ACID）
原子性：要么都成功。要么都失败
一致性：操作前后总量不变
持久性：持久化
隔离性：各个事务相互隔离
? ? ? ? ? ? ? ? ? ? ? ?2.4.3.xml文件实现事务管理器的配置：
1.配置数据源，数据库连接池
2.配置TranstactionalManager 的bean实例
<bean name="TransactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
3.开启事务管理
<!--配置事务管理器-->
<tx:annotation-driven transaction-manager="TransactionManager"/>
4.@Transaction注释需要开启事务的类
? ? ? ? ? ? ? ? ? ? ?2.4.4.事务的传播行为：
事务的传播行为有7种：主要记住required required_new(1.有事务的话直接加入该事务。2.加入当前的事务的时候，当前事务先挂起，不干扰该事务的运行)
? ? ? ? ? ? ? ? ? ? ?2.4.5.事务的隔离级别：
事务的隔离级别解决的问题是，高并发下的读问题：1.脏读：读到了未提交的数据（读到的被修改但未提交的数据）2.不可重复读：读到了数据被修改（多次读到的数据前后不一致）3.幻读：独到的数据被增加、删除（多次读到的数据条数不一样）
READ_UNCOMMIT(读未提交)
READ_COMMIT（读已提交）
REPETABLE_READ（可重复读）mysql的默认事务隔离级别无法解决幻读
SERIALIZABLE（串行化，同步阻塞）
? ? ? ? ? ? ? ? ? ? ?2.4.6.全注解事务开发
/**
* @auoter:jackh
*/
@Configuration
@ComponentScan({"com"})//该扫描包配置需要和spring bean的注解联合使用
@EnableTransactionManagement//开启事务注解
public class TransactionalConfig {
@Bean//配置了bean的注解需要配置扫描包信息把bean注册进ioc容器
public DruidDataSource druidDataSource(){
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
druidDataSource.setUsername("root");
druidDataSource.setPassword("root");
druidDataSource.setUrl("jdbc:mysql://192.168.13.128:3306" +
"/jdbcTemple?useUnicode=true&characterEncoding=utf-8");
return druidDataSource;
}
//配置事务管理器
@Bean
public DataSourceTransactionManager dataSourceTransactionManager(){
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(druidDataSource());
return dataSourceTransactionManager;
}
@Bean
public JdbcTemplate jdbcTemplate(){
JdbcTemplate template = new JdbcTemplate();
template.setDataSource(druidDataSource());
return template;
}
}
@Transactional注解的参数
//参数说明1.事务的传播行为配置2.事务的隔离级别3.只读：只能查询4.超时自动回滚时间5.遇到什么异常回滚
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,readOnly = false,timeout = 5,rollbackFor = Exception.class)
@Service
public class serviceimpl implements s {
@Autowired
private mapper mapper;
@Override
public void service_sout() {
mapper.delete();
System.out.println("黄泽楷账户减少10块");
int a=10/0;//模拟异常
mapper.add();
}
}
注:整合日志log4j2
<dependencies>
<!-- 使用 log4j2 的适配器进行绑定 包含了slf4j-api、log4j-api、log4j-core-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.11.2</version>
</dependency>
<!-- spring5 -->
<!-- .... -->
<dependencies/>
<?xml version="1.0" encoding="UTF-8" ?>
<!-- 日志级别优先顺序：OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!-- configuration 后面的status 用于设置log4j2自身内部的信息输出，
当设置为trace时,可以看到log4j2内部详细信息输出-->
<configuration status="warn">
<!--
集中配置属性进行管理
使用时通过:${name}
-->
<properties>
<property name="LOG_HOME">D:/dev/logs/study</property>
<!-- 格式化输出：
%date / %d 表示日期; %thread / %t 表示线程名;
%logger{36} / %l 表示Logger名字最长36个字符;
%msg / %m 表示日志消息; %n是换行符;
%-5level 级别从左显示5个字符宽度;
-->
<property name="LOG_CONSOLE_OUT">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] [%-5level] %l{36} - %m%n</property>
<property name="LOG_FILE_OUT">%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%-5level] %logger{36} - %msg%n
</property>
</properties>
<!-- 日志处理 -->
<appenders>
<!-- 1.控制台输出 SYSTEM_OUT 输出黑色，SYSTEM_ERR输出红色 -->
<console name="console" target="SYSTEM_OUT">
<!-- 文件输出格式-->
<PatternLayout pattern="${LOG_CONSOLE_OUT}"/>
</console>
<!-- 2.文件输出-->
<!-- 文件输出还可以配置 File、RandomAccessFile、RollingFile、RollingRandomAccessFile 等节点 实现不同要求的文件输出 -->
<!-- fileName：文件拆分前的名称-->
<!-- filePattern：文件拆分后的名称，满足拆分条件 进行拆分-->
<RollingRandomAccessFile name="rollingRandomAccessFile"
fileName="${LOG_HOME}/rollingRandomAccessFile.log"
filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/%d{yyyy-MM-dd HHmm}.log">
<PatternLayout pattern="${LOG_FILE_OUT}"/>
<!-- 日志级别过滤器 info (上) > debug (下)-->
<!--
onMatch="ACCEPT" 表示匹配该级别及以上
onMatch="DENY" 表示不匹配该级别及以上
onMatch="NEUTRAL" 表示该级别及以上的，由下一个filter处理，如果当前是最后一个，则表示匹配该级别及以上
onMismatch="ACCEPT" 表示匹配该级别以下
onMismatch="NEUTRAL" 表示该级别及以下的，由下一个filter处理，如果当前是最后一个，则不匹配该级别以下的
onMismatch="DENY" 表示不匹配该级别以下的
-->
<ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
<!-- 文件拆分条件：满足拆分条件，则新建空文件，把已有文件内容存放到 filePattern 配置的地址中-->
<Policies>
<!-- 按照时间节点拆分，规则根据filePattern定义的 -->
<TimeBasedTriggeringPolicy/>
<!-- 按照文件大小拆分，10MB -->
<SizeBasedTriggeringPolicy size="2MB"/>
<!-- 每启动一次系统，则生成一个新的日志文件 -->
<!-- OnStartupTriggeringPolicy/>-->
</Policies>
</RollingRandomAccessFile>
</appenders>
<!-- loggers 定义 -->
<Loggers>
<!--appenders 定义的子节点，只有在 logggers 中使用 AppenderRef 进行引用之后才会生效-->
<root level="info">
<AppenderRef ref="console"/>
<AppenderRef ref="rollingRandomAccessFile"/>
</root>
<!-- 为指定包 设置日志级别 , JdbcTemplate 打印sql语句-->
<logger name="org.springframework.jdbc.core.JdbcTemplate" level="DEBUG">
<!-- 如果定义了AppenderRef
则该日志信息只在配置的AppenderRef中生效，
否则继承root下的全部AppenderRef -->
<AppenderRef ref="console"/>
</logger>
</Loggers>
</configuration>
|