【Doc】Spring框架

已于 2024-08-01 21:17:15 修改
阅读量188 收藏
点赞数
分类专栏： Spring 全家桶 文章标签： spring ioc aop
于 2020-07-17 21:37:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Start1234567/article/details/107418307
版权

1、Spring

1.1、简介

  • Spring框架是由于软件开发的复杂性而创建的。
  • Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。
  • 然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

官方文档：https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

1.2、优点

  • Spring是一个开源的免费框架（容器）
  • Spring是一个轻量级的、非入侵式的框架
  • 控制反转（IOC），面向切面（AOP）使得编程变得简单
  • 支持事物的处理，对框架整合的支持

总结一句话：spring是轻量级的控制反转和面向切面编程的框架

2、IOC创建对象的方式

什么是IOC控制反转 ：对象有spring来创建，管理装配

创建方式：

1、使用无参构造创建对象，默认！

<bean id="gogo" class="com.cl.pojo.Student">
    <property name="id" value="1"/>
    <property name="name" value="小号"/>
</bean>

2、使用有参构造创建对象

  • 下标赋值
<bean id="All" class="com.cl.pojo.Student">
    <constructor-arg index="0" value="12"/>
    <constructor-arg index="1" value="小明"/>
</bean>
  • 通过参数名
<bean id="a2" class="com.cl.pojo.Student">
    <constructor-arg name="id" value="13"/>
    <constructor-arg name="name" value="小红"/>
</bean>

3、Spring配置

  • 可以给Bean起别名
<bean id="gogo" class="com.cl.pojo.Student">
    <property name="id" value="1"/>
    <property name="name" value="小号"/>
</bean>
    
<alias name="gogo" alias="student"/>
  • Bean的配置
<!--
    id : bean 的唯一标识符，也就是相当于对象名
    class : bean 对象对应的权限定名： 包名 + 类型
    name : 也是别名，而且name可以同时去多个别名
-->
<bean id="gogo" class="com.cl.pojo.Student" name="s1,s2 s3;s4">
    <property name="id" value="1"/>
    <property name="name" value="小号"/>
</bean>
  • import 可以将几个Bean合并成一个

在这里插入图片描述

<?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">
    <import resource="Bean.xml"/>
    <import resource="Bean2.xml"/>
</beans>

4、依赖注入

4.1、构造器注入

前面构造器创建对象，为对象赋值就是构造器注入

4.2、Set方法注入【重点】

1、复杂类型

public class Address {
    private String address;
}

2、真实测试对象

public class Teacher {
    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;
}

3、bean.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="Address" class="com.cl.pojo.Address">
        <property name="address" value="上海"/>
    </bean>

    <bean id="teacher" class="com.cl.pojo.Teacher">
        <!--普通注入，value-->
        <property name="name" value="小张"/>

        <!--Bean注入，ref-->
        <property name="address" ref="Address"/>

        <!--数组注入-->
        <property name="books">
            <array>
                <value>Java基础</value>
                <value>Java进阶</value>
            </array>
        </property>

        <!--list集合注入-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>打球</value>
            </list>
        </property>

        <!--map集合注入-->
        <property name="card">
            <map>
                <entry key="身份证号" value="123124324325325"/>
                <entry key="学生证" value="124234"/>
            </map>
        </property>

        <!--set集合注入-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>bob</value>
            </set>
        </property>

        <!--空-->
        <property name="wife" value=""/>
        
         <!--null-->
        <property name="wife">
           <null/>
        </property>

        <!--properties 配置文件注入-->
        <property name="info">
            <props>
                <prop key="userName">root</prop>
                <prop key="passWord">123456</prop>
            </props>
        </property>
    </bean>
</beans>

4、测试类

public class TeacherCon {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Teacher teacher = (Teacher) Context.getBean("teacher");
        System.out.println(teacher.toString());
        /*
        Teacher(
        name=小张,
        address=Address(address=上海),
        books=[Java基础, Java进阶],
        hobbys=[听歌, 打球],
        card={身份证号=123124324325325, 学生证=124234},
        games=[lol, bob],
        wife=,
        info={passWord=123456, userName=root})
         */
    }
}

4.3、C、P命名空间注入

  • student
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private  String name;
}
  • Bean.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="student" class="com.cl.pojo.Student" p:id="12" p:name="小幅"/>

    <!--c命名空间注入，通过构造器注入：construct-args-->
    <bean id="sc" class="com.cl.pojo.Student" c:id="11" c:name="小张"/>

</beans>
  • 测试
@Test
    public void text01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Bean3.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }

注意点：C、P命名空间不能直接使用，需要导入xml约束！

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

5、Bean的作用域（scopes）

在这里插入图片描述

1、单例模式（Spring默认）可以显示定义 - scope = singleton

<bean id="student" class="com.cl.pojo.Student" p:id="12" p:name="小幅" scope="singleton"/>

2、原型模式：每次从容器中get的时候，都会产生一个新对象 - scope = prototype

<bean id="student" class="com.cl.pojo.Student" p:id="12" p:name="小幅" scope="prototype"/>

3、其余的request、session、application 这些只能在web开发中使用到

6、Bean的自动装配

  • 自动装配是Spring满足Bean依赖一种方式
  • Spring会在上下文中自动寻找，并自动给Bean装配属性

在Spring中有三种装配的方式：

1、在xml中显示的配置（之前使用Bean.xml配置就是这种方式）

2、在java中显示配置

3、隐式的自动装配【重要】

  • 环境搭建

    • Dog、Cat、People类
    public class Dog {
    public void shout(){
        System.out.println("dog ~ ");
    }
}

    public class Cat {
    public void shout(){
        System.out.println("cat ~ ");
    }
}

    @Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class People {
    private String name;
    private Dog dog;
    private Cat cat;
}

6.1、ByName自动装配

<bean id="cat" class="com.cl.pojo.Cat"/>
<bean id="dog" class="com.cl.pojo.Dog"/>

<!--ByName:会自动在容器上下文中查找和自己对象set方法后面的值对应的Bean id-->
<bean id="people" class="com.cl.pojo.People" autowire="byName">
   <property name="name" value="狂三"/>
</bean>

6.2、ByType自动装配

 <bean id="cat" class="com.cl.pojo.Cat"/>
 <bean id="dog" class="com.cl.pojo.Dog"/>

<!--ByType: 会自动在容器上下文中查找，和自己对象属性类型相同的Bean-->
<bean id="people2" class="com.cl.pojo.People" autowire="byType">
   <property name="name" value="狂三"/>
</bean>

小结：

  • byName的时候，需要保证所有的 Bean的id 唯一，并且这个Bean需要和自动注入的属性的set()方法的值一致。
  • byType的时候，需要保证所有的 class 唯一，并且这个bean需要和自动注入的属性的类型一致。

6.3、使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了

要使用注解须知：

1、导入约束 (context)

2、配置注解支持

<?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="cat111" class="com.cl.pojo.Cat"/>

    <bean id="dog111" class="com.cl.pojo.Dog"/>
    <bean id="dog222" class="com.cl.pojo.Dog"/>

    <bean id="qq" class="com.cl.pojo.People"/>
    
</beans>
  • Autowired注解
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class People {

    private String name;

    @Autowired
    @Qualifier(value = "dog111") //当容器中有多个对象时，可以用Quqlifier来指定使用那个
    private Dog dog;

    @Autowired(required = false) //required 设置为false，标识属性可以为空
    private Cat cat;
}
  • Resource注解
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class People {

    private String name;

    @Resource(name = "dog111") //当容器中有多个对象时，可以用name来指定使用那个
    private Dog dog;

    @Resource
    private Cat cat;
}

小结 autowired 与 resource 的区别：

​ @Autowired 是根据 ByType 实现的

​ @Resource 是根据 ByName 实现的

7、使用注解开发

1、属性如何注入

@Data
@Component  //组件可以被 component-scan 扫描装配
public class Student {
    @Value("小明")  // 等价于  <property name="name" value="小幅"/>
    private String name;
}

2、衍生的注解

@component 有几个衍生注解，主要用于分层

  • dao 【@Repository】
  • service 【@service】
  • controller 【@controller】

3、自动装配(6.3)

@Autowired    自动装配（ByType）
@Nullable     可以为空
@Resource     自动装配（ByName）

4、作用域

@Component
@Scope("singleton")  //singleton单例 prototype 多例
@Data
public class Student {

    @Value("小明")  // 等价于  <property name="name" value="小幅"/>
    private String name;

}

8、使用Java的方式配置Spring

我们现在完全不使用xml配置，全部交给java

  • 实体类
@Data
@Component
public class Student {

    @Value("小明")  // 等价于  <property name="name" value="小幅"/>
    private String name;
}
  • 配置类
//@Configuration 代表一个配置类，就和我们之前看到的Beans.xml 
//@Improt 导入其他的配置类，合并成一个
//@ComponentScan 扫描component组件
@Configuration
@ComponentScan("com.cl.pojo")
@Import(SpringBeanConfig.class)
public class SpringBeanConfig {
    
    //这个方法名相当于 Bean标签中的 id 属性
    //这个方法返回值相当于 Bean标签中的class属性  
    @Bean
    @Scope("singleton")  //prototype 原型（多例） singleton 单例
    public Student getStudent(){
        return new Student();
    }
}
  • 测试
@Test
    public void test02() {
        ApplicationContext context = new AnnotationConfigApplicationContext("com.cl");
        Student student = (Student) context.getBean("getStudent");
        System.out.println(student);
    }

9、AOP切面

9.1、什么是AOP

  • AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
  • AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
  • 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

9.2、AOP在spring中的作用

提供声明式事务，允许用户自定义切面

  • 切面（Aspect）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

  • 连接点（Joint point）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

  • 切入点（Pointcut）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

  • 通知（Advice）：Advice 定义了在 pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

9.3、使用Spring实现AOP

需要添加的依赖：

<!--切面需要的加包 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

方式一：使用Spring的API接口

  • 实现接口类
public class LOG1 implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"类，执行"+method.getName()+"方法");
    }
}

public class LOG2 implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行"+method.getName()+"方法， 返回值为"+returnValue);
    }
}
  • Application.xml中配置AOP
<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.cl.service.UserServiceImpl"/>
    <bean id="log1" class="com.cl.config.LOG1"/>
    <bean id="log2" class="com.cl.config.LOG2"/>

    <aop:config>
        <!--切入点-->
        <aop:pointcut id="UserService" expression="execution(* com.cl.service.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="log1" pointcut-ref="UserService"/>
        <aop:advisor advice-ref="log2" pointcut-ref="UserService"/>
    </aop:config>

</beans>
  • 测试类
public class UserController {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("Application.xml");
        //动态代理 - 代理的是接口
        UserService bean = (UserService) Context.getBean("userService");
        bean.add();
    }
}

注意点：AOP是用动态代理来实现的，所以要强转为接口类型（UserService）

方式二：使用自定义切面实现

  • 自定义切面
public class AspectLOG {
    public void before(){        System.out.println("===================before====================");
    }
    public void after(){
        System.out.println("===================after====================");
    }
}
  • Application.xml中配置AOP
<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.cl.service.UserServiceImpl"/>

    <!--切面类-->
    <bean id="log" class="com.cl.config.AspectLOG"/>

    <aop:config>
        <!--引入切面类 -->
        <aop:aspect ref="log">
            <!--要切入的点-->
            <aop:pointcut id="UserService" expression="execution(* com.cl.service.UserServiceImpl.*(..))"/>
            <!--切入点之前执行，method对应切面类中名称相同的方法-->
            <aop:before method="before" pointcut-ref="UserService"/>
            <!--切入点之后执行，method对应切面类中名称相同的方法-->
            <aop:after method="after" pointcut-ref="UserService"/>
        </aop:aspect>
    </aop:config>

</beans>
  • 测试类
public class UserController {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("Application.xml");
        //动态代理 - 代理的是接口
        UserService bean = (UserService) Context.getBean("userService");
        bean.add();
    }
}

方式三：注解实现AOP

  • 自定义切面类
@Aspect
public class AnnotcationLOG {

    @Before("execution(* com.cl.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===========before===========");
    }

    @After("execution(* com.cl.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===========after===========");
    }

    /*环绕通知*/
    @Around("execution(* com.cl.service.UserServiceImpl.*(..))")
    public void arount(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");

        Signature signature = jp.getSignature();//获得签名
        System.out.println("signature:"+signature);

        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}
  • Application.xml 中配置AOP注解支持
<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.cl.service.UserServiceImpl"/>

    <!--第三种方式-->
    <!--切面类交给spring管理-->
    <bean id="Annotcation" class="com.cl.config.AnnotcationLOG"/>
    <!--开启AOP注解支持-->
    <aop:aspectj-autoproxy/>
</beans>
  • 测试
public class UserController {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("Application.xml");
        //动态代理 - 代理的是接口
        UserService bean = (UserService) Context.getBean("userService");
        bean.add();
    }
}

在这里插入图片描述

10、Spring整合Mybatis

官方文档：http://mybatis.org/spring/zh/index.html

第一种方式：

  • 实体类
@Data
public class User {
    private Integer id;
    private String name;
    private String pwd;
}
  • UserMapper
public interface userMapper {
    List<User> getUserList();
}
  • UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Mapper接口-->
<mapper namespace="com.cl.Mapper.userMapper">

    <!--select查询语句 id对应UserMapper中的方法名-->
    <select id="getUserList" resultType="User">
       select * from user
   </select>

</mapper>
  • spring-dao.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="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;characterEncoding=UTF-8"/>
         <property name="username" value="root"/>
         <property name="password" value="123456"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--可以通过configLocation来加入其他配置-->
        <property name="configLocation" value="classpath:Mybatis-config.xml"/>
        <!--添加mapper映射-->
        <property name="mapperLocations" value="classpath:com/cl/mapper/*.xml"/>
    </bean>

    <!--sqlSessionTemplate：就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory 应为他没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
</beans>
  • 实现类
package com.cl.mapper;

import com.cl.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl  implements  UserMapper {
    private SqlSessionTemplate session;

    public void setSession(SqlSessionTemplate session) {
        this.session = session;
    }

    public List<User> getUserList() {
        return session.getMapper(UserMapper.class).getUserList();
    }
}
  • 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"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="Spring-dao.xml"/>

    <bean id="UserMapperImpl" class="com.cl.mapper.UserMapperImpl">
        <property name="session" ref="sqlSession"/>
    </bean>

</beans>
  • 测试类
public class UserController {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapperImpl userMapperImpl = (UserMapperImpl) context.getBean("UserMapperImpl");
        List<User> userList = userMapperImpl.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

第二种方式：

  • 实现类
public class UserMapperImpl extends SqlSessionDaoSupport implements  UserMapper {

    public List<User> getUserList() {
        return getSqlSession().getMapper(UserMapper.class).getUserList();
    }
}
  • 配置
<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="Spring-dao.xml"/>


    <bean id="UserMapperImpl" class="com.cl.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

11、spring中的事务（AOP声明事事务）

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--数据源-->
    <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;characterEncoding=UTF-8"/>
         <property name="username" value="root"/>
         <property name="password" value="123456"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--可以通过configLocation来加入其他配置-->
        <!--<property name="configLocation" value="classpath:Mybatis-config.xml"/>-->
        <!--添加mapper映射-->
        <property name="mapperLocations" value="classpath:com/cl/mapper/*.xml"/>
    </bean>

    <!--sqlSessionTemplate：就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory 应为他没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="datasource" />
    </bean>
    <!--结合aop实现事务织入-->
    <!--配置事务通知-->
    <tx:advice id="transaction" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add"/>
            <tx:method name="*"/>  <!--所有方法-->
        </tx:attributes>
    </tx:advice>

    <!--aop织入事务-->
    <aop:config>
        <aop:pointcut id="tranPoincut" expression="execution(* com.cl.mapper.*.*(..))"/>
        <aop:advisor advice-ref="transaction" pointcut-ref="tranPoincut"/>
    </aop:config>

</beans>

狂神说：https://www.bilibili.com/video/BV1WE411d7Dv?p=14

偷偷写博客
关注
专栏目录
Spring框架简介.doc
10-20
Spring框架是Java开发中广泛应用的一个轻量级框架，它的出现极大地简化了企业级应用的开发工作。Spring的主要设计理念是提供一种“低耦合高内聚”的解决方案，通过控制反转（IoC）和面向切面编程（AOP）等技术，实现...
Spring框架系列(2) - Spring简单例子引入Spring要点.doc
07-13
Spring 框架系列（2）- Spring 简单例子引入 Spring 要点 本文主要承接上文，向您展示 Spring Framework 组件的典型应用场景和基于这个场景设计出的简单案例，并以此引出 Spring 的核心要点，比如 IOC 和 AOP 等。...
Spring框架
qq_39519747的博客
03-26 382
1.Spring是什么及Spring的优点①. Spring是一个轻量级的IOC和AOP容器框架②. Spring是非侵入式的，基于Spring开发的应用一般不依赖于Spring的类③. Spring是个容器，因为它包含并且管理应用对象的生命周期和配置，比如对象的创建、销毁、回调等④. Spring提供对事务的管理⑤. Spring对主流的框架提供了很好的集成支持，比如和hibernate Spr...
Spring框架内容整理（一）：IOC
简单世界的博客
08-22 1206
Spring架构模块,IOC概念，
Spring 整理
qq_43658155的博客
06-07 1081
START author：空巷 WeChat Applet ：Java空巷 QQ： 2399014502 Mail： ycw2399014502@163.com WeiBo : KongXiang_ WeChat： Spring 推荐学习路径：http://c.biancheng.net/view/4242.html Spring 被称为 J2EE 的春天，是一个开源的轻量级的 Java 开发框架， 具有控制反转（IoC）和面向切面（AOP）两大核心。Java Spring 框
整理一下spring框架
Roenfee的博客
08-22 146
spring注解
Spring框架梳理
jessica_ff的博客
05-08 295
Spring Spring 经典教程 Spring知识点 spring系列包含非常多的项目，可以满足java开发中的方方面面 一、5个常用的spring框架 1.spring framework 也就是我们经常说的spring框架，包括了ioc依赖注入，Context上下文、bean管理、springmvc等众多功能模块，其他spring项目比如spring boot也会依赖spring框架 ...
Spring框架系列(1) - Spring和Spring框架组成.doc
07-09
Spring框架是Java开发领域中的一个基石，它由Rod Johnson在其著作《Expert One-on-One J2EE Design and Development》中首次提出核心思想，于2002年正式发布。Spring框架的诞生旨在解决J2EE应用程序开发中的复杂性，...
spring5 框架 中文文档_spring-framework-5-doc-cn.zip
03-20
Spring框架是Java后端开发中的核心框架之一，它以其强大的依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）能力而著名。Spring5是该框架的一个重要版本，带来了许多新特性...
Spring 应用框架技术面试题.doc
05-25
本篇文章将深入探讨Spring框架的几个关键知识点，以帮助你准备Spring技术的面试。 1. **Spring与Struts的区别** - Struts是基于Model-View-Controller（MVC）模式的Web层框架，专注于处理HTTP请求和响应，主要负责...
Spring框架整理1
Albert_yin的博客
04-13 444
spring是一个开源框架,spring是于2003年兴起的一个轻量级的java开发框架,由rod johnson在其著作expert one-on-one j2ee development and design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为j2ee应用程序开发提供集成的框架....
Spring框架整理
李坚强的博客
07-25 291
ioc底层原理 使用技术 1.XML 2.Dom4j 解析 xml 3.工厂设计模式 （解耦） 4.反射 第一步 创建XML 配置文件，配置要创建 对象类 //class 后面是全路径 第二步 创建工厂类，使用dom4j 解析配置文件+反射创建对象 //返回Service 对象方法： public static Service getService()...
Spring框架复习整理
SmileCoder
10-24 150
Spring框架学习过程内容整理 1、Spring框架相关概述 2、核心思想IoC、AoP 3、Spring框架基础应用和源码分析 4、 Spring AoP剖析 4、Spring事务
Spring整理
qq_31539771的博客
10-21 146
Spring框架的设计目标，设计理念，和核心是什么 Spring设计目标：Spring为开发者提供一个一站式轻量级应用开发平台； Spring设计理念：在JavaEE开发中，支持POJO和JavaBean开发方式，使应用面向接口开发，充分支持OO（面向对象）设计方法；Spring通过IoC容器实现对象耦合关系的管理，并实现依赖反转，将对象之间的依赖关系交给IoC容器，实现解耦； Spring框架的核心：IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入
Spring框架的全面详解（个人学习总结）
最新发布
2301_77760397的博客
01-24 2592
本文是笔者在学习和工作中使用Sping框架时所得出的一些个人理解以及学习总结，涉及到了Spring框架的两大核心技术点IOC与AOP的讲解，Spring框架中的设计模式讲解等一系列技术，本文将采用文字与代码结合的方式讲解，以此来提高大家的理解程度。
梳理spring-总结篇
拿来主义的专栏
06-11 1591
spring Spring致力于提供一种方法管理你的业务对象。 我喜欢他的说法，因为最初的初衷，才有了spring,这个富于革命性的开源轻量框架。 1.方便解耦，简化开发 通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层
一些写得好的Spring博客收集整理
laiwenqiang的专栏
12-28 3170
打算重新梳理一下Spring，查了不少资料，以下记录一些值得收藏的相关博客：  关于IoC的实现，博主写了个小例子模仿Spring，类名也是仿照Spring来定义，主要是关于BeanFactory、ApplicationContext和BeanDefinition的简单功能和相互调用。    详细地址：1000行代码读懂Spring（1）- 实现一个基本的IOC容器
spring基础知识整理
DFL_always的专栏
12-06 6031
spring学习的总结1、什么是Spring的Ioc容器spring容器就是常说的Ioc容器，即控制翻转，作为程序员，当我们去实例化一个 对象时，通常需要手动new创建一个对象，并且去跟踪该对象的生命周期，内存分配，内存释放等情况，这样对我们写代码会造成很大不方便，而使用spring容器，spring的实例化new交给容器，我们使用 getBean获取该对象即可，不需要去管理对象。DI 是指依赖注入
Spring框架总结【无比详细】
热门推荐
zp的博客
08-07 25万+
以下内容是我在初学spring时候做的笔记，当时是把比较放在了备忘录里面，如今把笔记重整到csdn上，为了复习也为了分析给大家，笔记写的算比较完整，回看自己做的还是有点羞涩。如有错误之处，欢迎指正，当我日后更强大的时候，我会不断的对内容进行补充和完善。当然学习也就是这么一个过程，学习-实践-总结-实践-总结... 转载请申明原文地址，希望大家支持，谢谢。 1、IOC和DI IOC: ...
Spring框架解析与实例化机制探索
"Spring框架浅浅谈 - 孙力波" Spring框架是Java开发中的核心框架，它提供了一个全面的编程和配置模型，旨在简化企业级应用的开发。Spring以其依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值