spring学习笔记

Sofiax

于 2020-10-13 19:10:37 发布

阅读量78

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/weixin_43937178/article/details/109002055

版权

本文详细介绍了Spring框架的核心概念，包括IOC容器、DI依赖注入的多种方式，如构造器注入、setter注入和扩展方式注入。此外，还讨论了bean的作用域、自动装配策略，如byName和byType，并展示了如何使用注解实现自动装配。同时，文章涵盖了基于Java配置的方式、AOP面向切面编程的使用，以及如何整合MyBatis和声明式事务管理。

摘要由CSDN通过智能技术生成

1.spring

spring是一个容器，使用配置文件自动创建对象（bean）,并在bean中配置对象的属性；
spring比较重要的点有IOC(控制反转–>spring利用反射创建对象–>解耦)，DI(依赖注入，注入对象属性值)，AOP（面向切面编程）。

2.配置文件

applicationContext.xml

<?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/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
   <bean id="user" class="com.kuang.pojo.User">
       <property name="name" value="sofia"/>
   </bean>
</beans>

3.DI依赖注入的方式

<bean id="student" class="com.kuang.pojo.Student">
        <constructor-arg value="12"/>
        <constructor-arg value="sofia"/>
    </bean>

要求实体类中必须有有参构造函数，constructor-arg value="xx"会按照构造函数中的参数的顺序及类型注入；
如果实体类中只有无参构造函数，那么constructor-arg value 将不能使用，结果显示实体类的属性都为null值；

3.1 构造器注入

spring容器调用带有参数的构造类完成属性注入，bean的表现为：

3.2 set方法注入

实体类为：

 private String name;
    private Address address;  //引用类型
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

涉及了多个类型，对于不同的类型，bean属性值为：

<property name="name" value="sofia"/>

<property name="address" ref="address"/>

<property name="books">
    <array>
        <value>Java</value>
        <value>Python</value>
        <value>Linux</value>
        <value>spring</value>
    </array>
</property>

<property name="hobbys">
    <list>
        <value>看书</value>
        <value>跑步</value>
        <value>阅读</value>
    </list>
</property>

<property name="card">
    <map>
        <entry key="A" value="a"/>
        <entry key="B" value="b"/>
        <entry key="C" value="c"/>
    </map>
</property>

<property name="games">
    <set>
        <value>BOB</value>
        <value>LOL</value>
        <value>DNF</value>
    </set>
</property>

<property name="wife" value=""/>

<property name="info">
    <props>
        <prop key="学号">201893364</prop>
        <prop key="手机号">188385</prop>
        <prop key="姓名">Sofia</prop>
    </props>
</property>

3.3 扩展方式注入

使用p、c命名空间的方式注入，需要添加xml约束，如下：

p命名空间

xmlns:p="http://www.springframework.org/schema/p"

bean标签的书写方式为：

 <bean id="user" class="com.kuang.pojo.User" p:name="sofia" p:age="12"/>

c命名空间（实体类应包含有参构造函数）

xmlns:c="http://www.springframework.org/schema/c"

bean标签的书写方式为：

    <bean id="user1" class="com.kuang.pojo.User" c:name="sofia" c:age="12"/>

3.4 bean的作用域

默认的是单例Singleton ，常用的还有Prototype 原型模式，每次创建都创建新的对象，在bean标签中使用scope属性定义：

    <bean id="student" class="com.kuang.pojo.Student" scope="singleton">
     <bean id="student" class="com.kuang.pojo.Student" scope="prototype ">

其余还有request，session，application在web开发中经常遇到；

4. bean的自动装配

4.1 byName,byType

自动装配是spring满足bean依赖的一种方式
spring通过上下文查找的方式，自动将依赖注入

spring有三种装配的方式：

在xml文件中显示的配置
在Java中显示配置
隐式自动装配

具体实现：自动装配通过bean标签的autowire属性，可选择的自动注入方式有byName，byType;

byName :spring通过在上下文中查找和自己bean的set方法后面的值相同的bean的id，然后自动注入；(要求bean的id值必须唯一–>即对象名相同)

<bean id="cat" class="com.sofia.pojo.Cat"/>
<bean id="dog" class="com.sofia.pojo.Dog"/>
<bean id="person" class="com.sofia.pojo.Person" autowire="byName">
    <property name="name" value="sofia"/>
</bean>

byType ::spring通过在上下文中查找和自己对象属性类型相同的bean方法后面的值的bean的id，然后自动注入；（要求具有该类型的对象必须全局唯一）

    <bean id="person" class="com.sofia.pojo.Person" autowire="byType">

4.2 使用注解完成自动装配

使用注解需知：

导入约束：

 xmlns:context="http://www.springframework.org/schema/context"

配置以支持注解

 <context:annotation-config/>

完整的配置文件为：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
   
    <context:annotation-config/>
   
     <bean id="dog" class="com.sofia.pojo.Dog"/>
    <bean id="cat" class="com.sofia.pojo.Cat"/>
    <bean id="person" class="com.sofia.pojo.Person"/>

</beans>

4.2.1 在实体类中使用 @Autowired开启自动注入

 @Autowired
 private Dog dog;
 @Autowired
 private Cat cat;

当出现类相同但对象名称不同的情况时，使用@Autowired会报错；此时搭配 @Qualifier(“dog21”)指定某个具体的对象即可

<bean id="dog11" class="com.sofia.pojo.Dog"/>
<bean id="dog21" class="com.sofia.pojo.Dog"/>

@Autowired
@Qualifier("dog21")
private Dog dog;

4.2.2 也可以使用@Resource实现自动装配

默认使用ByName,如果找不到则使用byType，都找不到则报错；可以使用@Resource(name=“xxx”)解决冲突

5. 使用注解开发

要使用注解开发，必须导入context约束，如上文配置文件。

5.1 @Component

表示将当前类注册到spring容器中，装配bean；
需要在配置文件中配置要扫描的包：

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

可以搭配@Value注解使用，给类的某个属性添加值：(则name=“sofia”)

@Component
public class User {
  @Value("sofia")
  private String name;

5.2 由component衍生出的其他几个注解

【dao】 -->@Repository
【service】–> @Service
【controller】–>@Controller

和@component一样，以上几个注解的含义也只是表示当前类被注册到spring容器中，只是针对MVC三层使用不同的注解。
注：使用注解需要在配置文件中配置当前类是可被spring扫描到的。

5.3 自动装配（类属性）的注解

@Autowired
@Qualifier
@Resource

5.4 作用域

@Scope(“prototype”)写在类上表示当前类装配的bean的作用域。

@Component
@Scope("prototype")
public class User {
    @Value("sofia")
    private String name;

5.5 总结

xml配置文件适用于项目中的所有类，但是注解只适用于当前类；
通常使用xml文件生成bean，使用注解完成属性注入。

6. 基于Java的方式配置spring

使用@Configuration注解
在这里插入图片描述
编写Java配置类，并使用@Configuration注解（该注解内部其实是包含@Component注解），在使用的使用直接mapper.getBean(“方法名”).

7.AOP(面向切面编程)

使用AOP首先需要导入一个依赖

<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.9.5</version>
</dependency>

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
        </beans>

7.1 使用Spring API完成AOP

导入约束

 <!--导入AOP的约束-->
    <aop:config>
        <!--exection要执行的位置：配置指定类下的所有方法（所有参数..）-->
        <aop:pointcut id="pointcut" expression="execution(* com.sofia.service.userServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="logBefore" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="logAfter" pointcut-ref="pointcut"/>
    </aop:config>

自定义类并实现spring相关接口MethodBeforeAdvice 、AfterReturningAdvice（通知）

public class logBefore implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass()+"类的"+method.getName()+"方法被执行了");
    }
}

public class logAfter implements AfterReturningAdvice{
    public void afterReturning(Object returnVal, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println(method.getName()+"方法执行了,返回值为"+returnVal);
    }
}

7.2 自定义切面，配合AOP属性

自定义切面

public class MyPointCut {
    public void  myBefore(){
        System.out.println("=======方法执行前=========");
    }
    public void myAfter(){
        System.out.println("========方法执行后========");
    }
}

配置：

<bean id="myPointCut" class="com.sofia.myPt.MyPointCut"/>

<aop:config>
   <!--自定义切面，引入切面所在的类-->
   <aop:aspect ref="myPointCut">
       <!--切入点（要添加切面的目标类/方法）-->
       <aop:pointcut id="pointcut" expression="execution(* com.sofia.service.userServiceImpl.*(..))"/>
       <!--通知：要给目标添加的具体内容（自定义的切面）-->
       <aop:before method="myBefore" pointcut-ref="pointcut"/>
       <aop:after method="myAfter" pointcut-ref="pointcut"/>

    </aop:aspect>
</aop:config>

7.3 使用注解AOP

配置

 <!--第三种：开启注解支持-->
   <bean id="annoPoint" class="com.sofia.annotation.annoPoint"/>
   <aop:aspectj-autoproxy/>

-Java类

//声明当前类是一个切面
@Aspect
public class annoPoint {
    @Before("execution(* com.sofia.service.userServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }

    @After("execution(* com.sofia.service.userServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }
}

8. 整合mybatis

传统的使用mybatis需要经历的过程为：

编写配置文件（mybatis-config.xml）
编写实体类；
根据实体类编写持久层方法；l
编写映射文件（xxx.xml）
在配置文件中还需要配置数据源，配置映射；
当要使用映射文件中的sql时，需要使用SqlSessionFactoryBuilder解析配置文件生成 sqlSessionFactory，再sqlSessionFactory（相当于一个池子）生产sqlSession，由sqlSession.getMapper(xxx.class)通过反射机制获取对应的实例；

使用spring整合mybatis的配置文件为：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--使用spring的数据源替换mybatis的配置-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;charcterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
     </bean>

    <!--配置一个sqlSessionfactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--配置mybatis的mapper-->
        <property name="mapperLocations" value="classpath:com/sofia/mapper/*.xml"/>
    </bean>

    <!--使用sqlSessionTemplate(模板) 生产sqlsession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="userMapper" class="com.sofia.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

由spring装配sqlSessionfactory，sqlsession完成配置。

9. 声明式事务

结合AOP实现事务

配置声明式事务->bean

  <!--配置声明式事务-->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource"/>
   </bean>

配置事务通知

<tx:advice id="txAdvice" transaction-manager="transactionManager">
       <tx:attributes>
           <tx:method name="add" propagation="REQUIRED"/>
           <tx:method name="delete" propagation="REQUIRED"/>
           <tx:method name="update" propagation="REQUIRED"/>
           <tx:method name="query" read-only="true"/>
       </tx:attributes>
   </tx:advice>

配置事务切入

<aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.sofia.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

注：事务的传播特性：
在这里插入图片描述