Spring详解

最新推荐文章于 2024-06-20 11:22:17 发布

Dream

最新推荐文章于 2024-06-20 11:22:17 发布

阅读量420

点赞数 1

分类专栏： spring 文章标签： Spring

本文链接：https://blog.csdn.net/weixin_43705313/article/details/103058960

版权

spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一丶首先理解耦合和解耦：

程序的耦合
       耦合：程序间的依赖关系
          包括：
               类之间的依赖
               方法间的依赖
       解耦：
           降低程序间的依赖关系
       实际开发中：
           应该做到：编译期不依赖，运行时才依赖。
       解耦的思路：
           第一步：使用反射来创建对象，而避免使用new关键字。
           第二步：通过读取配置文件来获取要创建的对象全限定类名

初识Spring:

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>

获取spring的Ioc核心容器，并根据id获取对象
     * ApplicationContext的三个常用实现类：
     *             ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
     *              FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
     *
     *              AnnotationConfigApplicationContext：它是用于读取注解创建容器的
     * 核心容器的两个接口引发出的问题：
     * ApplicationContext:     单例对象适用采用此接口
     *      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
     * BeanFactory:            多例对象使用
     *      它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\zhy\\Desktop\\bean.xml");
        //2.根据id获取Bean对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);

        System.out.println(as);
        System.out.println(adao);
        as.saveAccount();

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
        <property name="name" value="TEST" ></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>

<context:component-scan base-package="com.itheima"></context:component-scan>

曾经XML的配置：
* <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"
*        scope="" init-method="" destroy-method="">
*      <property name="" value="" | ref=""></property>
* </bean>
*
* 用于创建对象的
*      他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
*      Component:
*          作用：用于把当前类对象存入spring容器中
*          属性：
*              value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
*      Controller：一般用在表现层
*      Service：一般用在业务层
*      Repository：一般用在持久层
*      以上三个注解他们的作用和属性与Component是一模一样。
*      他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰
*
*
* 用于注入数据的
*      他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
*      Autowired:
*          作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功
*                如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
*                如果Ioc容器中有多个类型匹配时：
*          出现位置：
*              可以是变量上，也可以是方法上
*          细节：
*              在使用注解注入时，set方法就不是必须的了。
*      Qualifier:
*          作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以（稍后我们讲）
*          属性：
*              value：用于指定注入bean的id。
*      Resource
*          作用：直接按照bean的id注入。它可以独立使用
*          属性：
*              name：用于指定bean的id。
*      以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
*      另外，集合类型的注入只能通过XML来实现。
*
*      Value
*          作用：用于注入基本类型和String类型的数据
*          属性：
*              value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式）
*                      SpEL的写法：${表达式}
*
* 用于改变作用范围的
*      他们的作用就和在bean标签中使用scope属性实现的功能是一样的
*      Scope
*          作用：用于指定bean的作用范围
*          属性：
*              value：指定范围的取值。常用取值：singleton prototype
*
* 和生命周期相关了解
*      他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的
*      PreDestroy
*          作用：用于指定销毁方法
*      PostConstruct
*          作用：用于指定初始化方法
*/
@Service("accountService")
//@Scope("prototype")
public class AccountServiceImpl implements IAccountService {

//    @Autowired
//    @Qualifier("accountDao1")
    @Resource(name = "accountDao2")
    private IAccountDao accountDao = null;

    @PostConstruct
    public void  init(){
        System.out.println("初始化方法执行了");
    }

    @PreDestroy
    public void  destroy(){
        System.out.println("销毁方法执行了");
    }

    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        
        <property name="accountDao" ref="accountDao"></property>
    </bean>


    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        
        <property name="runner" ref="runner"></property>
    </bean>

* 该类是一个配置类，它的作用和bean.xml是一样的
* spring中的新注解
* Configuration
*     作用：指定当前类是一个配置类
*     细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
* ComponentScan
*      作用：用于通过注解指定spring在创建容器时要扫描的包
*      属性：
*          value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。
*                 我们使用此注解就等同于在xml中配置了:
*                      <context:component-scan base-package="com.itheima"></context:component-scan>
* Bean
*      作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
*      属性:
*          name:用于指定bean的id。当不写时，默认值是当前方法的名称
*      细节：
*          当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。
*          查找的方式和Autowired注解的作用是一样的
* Import
*      作用：用于导入其他的配置类
*      属性：
*          value：用于指定其他配置类的字节码。
*                  当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类
* PropertySource
*      作用：用于指定properties文件的位置
*      属性：
*          value：指定文件的名称和路径。
*                  关键字：classpath，表示类路径下

//@Configuration
@ComponentScan("com.itheima")
@Import(JdbcConfig.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {


}

使用Junit单元测试：测试我们的配置
* Spring整合junit的配置
*      1、导入spring整合junit的jar(坐标)
*      2、使用Junit提供的一个注解把原有的main方法替换了，替换成spring提供的
*             @Runwith
*      3、告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置
*          @ContextConfiguration
*                  locations：指定xml文件的位置，加上classpath关键字，表示在类路径下
*                  classes：指定注解类所在地位置
*
*   当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {

    @Autowired
    private IAccountService as = null;


    @Test
    public void testFindAll() {
        //3.执行方法
        List<Account> accounts = as.findAllAccount();
        for(Account account : accounts){
            System.out.println(account);
        }
    }

    @Test
    public void testFindOne() {
        //3.执行方法
        Account account = as.findAccountById(1);
        System.out.println(account);
    }

    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("test anno");
        account.setMoney(12345f);
        //3.执行方法
        as.saveAccount(account);

    }

    @Test
    public void testUpdate() {
        //3.执行方法
        Account account = as.findAccountById(4);
        account.setMoney(23456f);
        as.updateAccount(account);
    }

    @Test
    public void testDelete() {
        //3.执行方法
        as.deleteAccount(4);
    }
}

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

<!--spring中基于XML的AOP配置步骤
        1、把通知Bean也交给spring来管理
        2、使用aop:config标签表明开始AOP的配置
        3、使用aop:aspect标签表明配置切面
                id属性：是给切面提供一个唯一标识
                ref属性：是指定通知类bean的Id。
        4、在aop:aspect标签的内部使用对应标签来配置通知的类型
               我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
               aop:before：表示配置前置通知
                    method属性：用于指定Logger类中哪个方法是前置通知
                    pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

            切入点表达式的写法：
                关键字：execution(表达式)
                表达式：
                    访问修饰符返回值包名.包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                    public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.itheima.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.itheima.service.impl.*.*(..)
    -->

Joinpoint(连接点):
        所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的
连接点。
Pointcut(切入点):
        所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):
         所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):
        引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
法或 Field。
Target(目标对象):
         代理的目标对象。
Weaving(织入):
         是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）:
          一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):
           是切入点和通知（引介）的结合。

<bean id="logger" class="com.itheima.utils.Logger"></bean>

<aop:config>
        
        <aop:aspect id="logAdvice" ref="logger">
            
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

<aop:config>
        
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        
        <aop:aspect id="logAdvice" ref="logger">
            

            

            

            

            
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

/**
     * 环绕通知
     * 问题：
     *      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     *      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     *
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */

 public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    @Pointcut("execution(* com.itheima.service.impl.*.*(..))") //表示这个包下的所有方法                             都是可以切入。
    private void pt1(){}

    /**
     * 前置通知
     */
//    @Before("pt1()")
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
//    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
//    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
//    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

<tx:advice id="txAdvice" transaction-manager="transactionManager">
        
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>

        3、配置AOP中的通用切入点表达式

        4、建立事务通知和切入点表达式的对应关系


    <aop:config>
        
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>

        5、配置事务的属性

               是在事务的通知tx:advice标签的内部

     -->