spring ioc、aop

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&amp;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>