Spring知识归整,速看速记!

2024-01-08 22:45:00

Spring知识归整,速看速记!

一、Spring介绍

1、Spring是什么?
Spring是轻量级的JAVAEE应用开源框架
2、Spring的好处?
IOC:控制反转
AOP:面向切面 粘合剂:整合其他技术和框架

二、IOC

1、耦合
    耦合:对象之间的依赖关系(service依赖于dao),耦合度越高维护的成本越高
    产生耦合的原因:硬编码
2、IOC
    控制:控制对象的创建
    IOC (Inverse of Control)即控制反转:正传是自己创建对象;反转是由工厂创建依赖对象
3、工厂模式的IOC解决程序耦合
    1.把dao和service配置到beans.properties
    2.读取beans.properties
    3.通过反射创建对象,并装到容器中
    4.在使用时,直接从容器中获得
4、spring的IOC解决程序耦合
    1.pom.xml
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.30</version>
        </dependency>
    2.log4j.properties
        复制mybatis
    3.applicationContext.xml
        <bean id="userDao" class="com.by.dao.UserDaoImpl" />
        <bean id="userService" class="com.by.dao.UserServiceImpl" />
    4、测试
        //带IOC容器的工厂
        ApplicationContext ac = new  ClassPathXmlApplicationContext("applicationContext.xml");
        ac.getBean("userService", UserService);

三、DI

1、什么是DI?
    DI(Dependency Injection)依赖注入:将依赖对象从容器中拿出来赋值给调用者
2、DI的方式
    1、构造方法注入
        public UserServiceImpl(UserDao userDao, String msg){
            this.userDao=userDao
            this.msg=msg
        }

        <bean id="userService" class="com.by.dao.UserServiceImpl" >
            <!--
                name="userDao":构造方法的参数名称
                ref="userDao":另一个bean标签的id
            -->
            <constructor-arg name="userDao" ref="userDao"></constructor-arg>
            <!--
                index="userDao":构造方法的参数的索引位置
                value="我靠":基本数据类型和String类型
            -->
            <constructor-arg index="0" value="我靠"></constructor-arg>
        </bean>
    2、set方法注入
        public setUserDao(UserDao userDao){
            this.userDao=userDao
        }

        public setMsg(String msg){
            this.msg=msg
        }

        <bean id="userService" class="com.by.dao.UserServiceImpl" >
            <property name="userDao" ref="userDao"></property>
            <property name="msg" value="我操"></property>
        </bean>
    3、自动注入
        //遍历map,并判断每个bean的类型,如果类型符合则赋值
        <bean id="userService" class="com.by.dao.UserServiceImpl" autowire="byType"></bean>

四、BeanFactory和ApplicationContext区别

ApplicationContext:子接口,加载配置文件时就创建对象
BeanFactory:顶级接口,使用对象时才创建

五、spring bean五种作用域(bean放哪了)

singleton:单例,ioc容器
prototype:多例,newInstance()
request:request域
session:session域
application:servletContext域

配置方式:<bean id="" class="" scope="prototype" />

单例和多例的使用场景?
    单例:service、dao、sqlSessionFactroy
    多例:connnect、sqlSession

六、spring bean的生命周期

1、案例:
    public class UserServiceImpl{

        private UserDao userDao;

        public UserServiceImpl(){
        }
        public setUserDao(){
        }
        public void init(){
        }
        public void destroy(){
        }
    }

    <bean id="" class="" scope="singleton"
              init-method="init" destroy-method="destroy" autowire="byType">
2、实验
    单例:
        [容器启动]---->构造方法(实例化)---->set方法(注入)---->init方法(初始化)---->[容器关闭]---->destroy方法(销毁bean)
    多例:
        [使用对象]---->构造方法(实例化)---->set方法(注入)---->init方法(初始化)---->[JVM垃圾回收]---->destroy方法(销毁bean)

七、spring基于注解的IOC

1、配置步骤
    1)pom.xml
        spring-context、slf4j-log4j12
    2.log4j.properties
        复制mybatis
    3)applicationContext.xml
        <context:component-scan base-package="com.by"></context:component-scan>
    4、ioc
        @Repository //<userDaoImpl, new UserDaoImpl()>
        public class UserDaoImpl{
        }
    5、DI
        public class UserServiceImpl{
            @Autowired
            private UserDao userDao;
        }

2、常用注解
    1)IOC
        @Controller:web
        @Service:service
        @Repository:dao
        @Component:三层架构之外
        @Scope("prototype"):指定bean的作用域范围,eg:singleton、prototype、request、session、application
    2)DI
        @Resource(name=""):按名称注入
        @Autowired:按类型
        @Value("${}"):注入基本类型和String类

八、AOP

1、为什么要使用AOP?
    有一万个service类,要求每个方法执行前打印日志,执行后打印日志
2、什么是AOP?
    AOP(Aspect Oriented Programming)面向切面编程:把程序中重复的代码抽取出来,使用动态代理的技术去执行,
    从而实现对方法的增强(不修改源代码对方法进行增强)
2、代理模式
    1)静态代理
        角色:
            公共接口:Star
            真实角色:RealStar(周杰伦.唱歌)
            代理角色:ProxyStar(宋吉吉.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)
            客户类:Client(小孩.调宋吉吉)

        缺陷:1.大量代码重复 2.只能代理Star类型的对象
    2)jdk动态代理
        角色:
            公共接口:Star
            真实角色:RealStar(周杰伦.唱歌)
            代理工厂:ProxyFactroy{生成ProxyStar(宋吉吉.面谈.订机票.签合同.[调周杰伦唱歌].收尾款)}
            客户类:Client(小孩.调宋吉吉)
    3)Cglib动态代理
        cglib和jdk动态代理的区别:cglib真实角色没有接口
3、aop的核心概念
    切点(pintcut):要增强的方法,eg:add()、update()
    通知/增强(advice):要搞的事情,eg:日志
        前置通知:aop:before
        后置通知:aop:after-returning【try】
        最终通知:aop:after【finally】
        异常通知:aop:after-throwing【catch】
        环绕通知:aop:around

        try{
            ...
            return aop:after-returning
        }catch(Exception e){
            ...
            aop:after-throwing
        }finally{
            ...
            aop:after
        }

    切面(aspect):把增强应用到切点上
4、切点表达式
    格式:execution([修饰符] 返回值 报名.类名.方法名(参数))
    eg:execution(* com.by.service.*.*(..))

5、基于xml的aop配置
    1)pom.xml
        spring-context、spring-aspects、slf4j-log4j12
    2)advice
        public class MyLogAdvice {

            public void before(){
                System.out.println("前置通知....");
            }
        }
    2)aop
        <!--增强(advice)-->
        <bean id="myLogAdvice" class="com.by.advice.MyLogAdvice"></bean>

        <aop:config>
                <!--切点(pintcut)-->
                <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/>
                <aop:aspect ref="myLogAdvice">
                            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
                </aop:aspect>
        </aop:config>

九、spring基于注解的aop配置

1)pom.xml
    spring-context、spring-aspects、slf4j-log4j12
2)advice
    @Component
    @Aspect
    public class MyLogAdvice {

        @Before("execution(* com.by.service.*.*(..)")
        public void before(){
            System.out.println("前置通知....");
        }
    }
3、开启spring对aop注解的支持
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

十、spring整合mybatis

1、pom.xml
    参考6.1.1
2、applicationContext.xml
    <!--加载db.properties-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--告诉mybatis扫描mapper接口生成代理类,并交给spring的ioc容器去管理-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.by.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
    </bean>

十一、spring整合junit

1、pom.xml
    spring-test、junit
2、test
    @RunWith(SpringJUnit4ClassRunner.class) //单元测试运行时带上spring环境
    @ContextConfiguration("classpath:applicationContext.xml")
    public class Client {
        @Autowired
        private UserService userService;
    }

十二、事务介绍

1)什么是事务?
    执行多条sql,要么全部执行,要么全部回滚
2)事务的特点
    原子性:事务是最小执行单位
    一致性:事务前后数据都是正确的
    隔离性:事务之间看不到彼此的中间状态
    持久性:事务一旦提交不可再回滚
3)mysql控制事务
    START TRANSACTION;
        sql1;
        sql2;
    COMMIT 或 ROLLBACK;
4)jdbc控制事务

    try{
        conn.setAutoCommit(false);
        ....
        conn.commit();
    }catch(Exception e){
        conn.rollback();
    }

十三、spring事务控制的api

1、PlatformTransactionManager
    作用:是一个事务管理器,负责开启、提交或回滚事务
    实现类:DataSourceTransactionManager(sqlSession)
2、TransactionDefinition
    作用:定义事务的属性
    实现类:DefaultTransactionDefinition
    属性:
        1)隔离级别【有默认值】
            DEFAULT:默认值,等价于REPEATABLE_READ
            READ_UNCOMMITTED    x         x              x
            READ_COMMITTED      脏读       x              x
            REPEATABLE_READ     脏读      不可重复度
            SERIALIZABLE        脏读      不可重复度       幻读
        2)事务的传播行为【有默认值】
            REQUIRED:默认值,methodB()会加入到methodA()事务中
        3)事务超时【有默认值】
            默认-1:永不超时
        4)是否只读【有默认值】
            readOnly = false:默认值,适用于增删改
            readOnly = true:不记录log(效率快),适用于查询
        5)回滚规则
            可省略:运行时异常回滚,编译时异常不回滚
3、TransactionStatus
    作用:代表一个事务

十四、spring的aop控制事务

    <!--增强(advice):要搞的事情,eg:日志、事务-->
    <tx:advice id="txManager" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*"></tx:method>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <!--切点(pointcut):要增强的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/>
        <!--切面(aspect):把增强应用到切点上-->
        <aop:advisor advice-ref="txManager" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>

    注意:方法名必须和事务属性的配置保持一致,eg:get或select开头

十五、spring的注解控制事务

<!--开启spring对事务注解的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

@Transactional
public class UserServiceImpl implements UserService {
}

文章来源:https://blog.csdn.net/qq_62124267/article/details/135466816
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。