快速学习spring

最新推荐文章于 2022-02-06 22:47:08 发布

java白中白.

最新推荐文章于 2022-02-06 22:47:08 发布

阅读量166

点赞数 2

分类专栏：快速学习spring 新手学spring javaWeb 文章标签： spring java

本文链接：https://blog.csdn.net/weixin_45794641/article/details/120187406

版权

javaWeb 同时被 3 个专栏收录

3 篇文章 0 订阅

订阅专栏

快速学习spring

1 篇文章 0 订阅

订阅专栏

新手学spring

1 篇文章 0 订阅

订阅专栏

spring

十分钟搭建spring项目

- spring

一、spring入门

1.理解IOC

Dao层有一个接口UserDao

public interface UserDao {
    void getUser();
}

有4个实现其的类，每个类中的实现类型都不一样

UserDaoImpl实现类

public class UserDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("查到数据!");
    }
}

UserDaoMysqlImpl实现类

public class UserDaoMysqlImpl implements UserDao {
    public void getUser() {
        System.out.println("Mysql查到数据！");
    }
}

UserDaoOracleImpl实现类

public class UserDaoOracleImpl implements UserDao {
    public void getUser() {
        System.out.println("Oracle查到数据！");
    }
}

UserDaoSqlServeImpl实现类

public class UserDaoSqlServeImpl implements UserDao {
    public void getUser() {
        System.out.println("SqlServe查到数据！");
    }
}

Service层有一个接口和一个实现类

UserService接口

public interface UserService {
    void getUser();
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService{
    public void getUser() {
    }
}

现要通过service层调用dao层的不同实现方法

测试类

public class Test {
    private static UserService userService=new UserServiceImpl();
    public static void main(String[] args) {
        userService.getUser();
    }
}

调用UserDaoImpl实现类，需要改UserServiceImpl为：

public class UserServiceImpl implements UserService{
    private UserDao userDao=new UserDaoImpl();
    public void getUser() {
        userDao.getUser();
    }
}

调用UserDaoMysqlImpl实现类，需要改UserServiceImpl为：

public class UserServiceImpl implements UserService{
    private UserDao userDao=new UserDaoMysqlImpl();
    public void getUser() {
        userDao.getUser();
    }
}

其他的以此类举，非常麻烦，每需要一个其他实现类就需要改动service代码，程序的控制权在于代码。

若将UserServiceImpl改成以下形式，就不用在service层修改代码。

将UserDao作为一个变量，设set方法，可以进行人工控制。

public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void getUser() {
        userDao.getUser();
    }
}

此时要使用UserDaoImpl实现类、UserDaoMysqlImpl实现类等等就相当方便：

public class Test {
    public static void main(String[] args) {
        UserServiceImpl userService=new UserServiceImpl();
        //调用UserDaoImpl实现类
        userService.setUserDao(new UserDaoImpl());
        //调用UserDaoMysqlImpl实现类
        userService.setUserDao(new UserDaoMysqlImpl());
        //调用UserDaoOracleImpl实现类
        userService.setUserDao(new UserDaoOracleImpl());
        //调用UserDaoSqlServeImpl实现类
        userService.setUserDao(new UserDaoSqlServeImpl());
    }
}

这样之后，从此程序员获得了控制程序的主动权，也减少了代码的耦合性，这就是IOC思想的简单体现。

在这里插入图片描述

2.导入依赖

 <!--Spring webmvc依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version/>5.2.0.RELEASE</version>
    </dependency>

3.核心配置文件

3.1普通核心配置文件

<?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">

</beans>

3.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
http://www.springframework.org/schema/context/spring-context.xsd">

<context:annotation-config/>
</beans>

4.添加bean

在核心配置文件中添加bean，其实就是将实体类注册到spring容器中，以后不用new实体类，只需要在spring容器中调用即可。

<bean id="hello" class="com.drl.entity.hello">
        <property name="str" value="Spring"/>
</bean>

5.测试

接下来获取spring容器，从spring容器中通过"getBean()"方法找到对象，以后只需要给容器中注册实体类，然后从容器中获取即可。

@Test
    public void test01(){
        //获取容器
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //在容器中获取对象
        hello hello = (hello) context.getBean("hello");
        String str = hello.getStr();
        System.out.println(str);
    }

6.回顾1

学到这里，现在将刚开始对IOC的理解转换成使用IOC容器的样子。

applicationContext.xml配置文件

 <!--在容器中注册dao层实现类-->
    <bean id="mysqlImpl" class="com.drl.dao.UserDaoMysqlImpl"/>
    <bean id="oracle" class="com.drl.dao.UserDaoOracleImpl"/>

    <!--
        1.在容器中注册service层实现类
        2.在注册对象时，如果要引用容器中已存在的对象，则需要用"ref"
    -->
    <bean id="serviceImpl" class="com.drl.service.UserServiceImpl">
        <property name="userDao" ref="mysqlImpl"/>
    </bean>
</beans>

测试

public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("serviceImpl");
        serviceImpl.getUser();
    }

7.spring容器

了解spring容器是怎么创建对象的。

证明1

spring容器是使用无参构造创建的

在实体类中写入无参构造，并输出一句话作为标记，测试从容器中拿对象是否使用无参构造创建

public class User {
    private String name;
    public User(){
        System.out.println("我是无参构造！");
    }
    public void setName(String name) {
        this.name = name;
    }
}

注入bean

<bean id="user" class="com.drl.entity.User"/>

测试,只获取对象

@Test
public void test01(){
    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = (User) context.getBean("user");
}

测试结果
在这里插入图片描述

证明2

spring容器是用set方法进行赋值

在实体类中去掉set方法

public class User {
    private String name;
    public User(){
    System.out.println("我是无参构造！");
    }
}

注入bean并赋值

<bean id="user" class="com.drl.entity.User">
    <property name="name" value="董瑞龙"/>
</bean>

会直接报错，如下
在这里插入图片描述

8.有参构造对象

上面介绍的是无参构造创建对象，下面是有参构造

实体类

public class User {
    private String name;
    private int age;
    
    public User(String name,int age){
        this.name=name;
        this.age=age;
    }
    
    public void setName(String name) {
        this.name=name;
    }
    public void setAge(int age) {
        this.age=age;
    }
}

方法一，通过下标创建

注意："index"中0指实体类中第一个属性，以此后推

<bean id="user" class="com.drl.entity.User">
    <constructor-arg index="0" value="董瑞龙"/>
    <constructor-arg index="1" value="21"/>
</bean>

方法二，通过参数名创建

<bean id="user" class="com.drl.entity.User">
    <constructor-arg name="age" value="21"/>
    <constructor-arg name="name" value="董瑞龙"/>
</bean>

二、spring配置

1.别名

别名使用"alias"标签，只能给已经注入bean的类起别名，起了别名之后，可以用原先的名字获取对象，也可用别名获取对象。

<bean id="user" class="com.drl.entity.User">
    <constructor-arg name="age" value="21"/>
    <constructor-arg name="name" value="董瑞龙"/>
</bean>

<alias name="user" alias="user2"/>

2.bean的配置

<!--
        id: bean的唯一标识符，相当于对象名
        class： bean的全限定名称：包名+类型
        name： 也是别名，而且可以取多个别名，可以用","、";"等符号来隔开
    -->
    <bean id="user" class="com.drl.entity.User" name="user2,user3;user4">
        <property name="age" value="21"/>
        <property name="name" value="董瑞龙"/>
    </bean>

3.import

import一般用于团队开发，它可以将多个配置文件导入合并为一个。
在这里插入图片描述

如上图，有三个配置文件，要将其他两个并入到applicationContext.xml中，则在applicationContext.xml文件中用"import"标签导入即可。

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>

三、DI依赖注入

1.构造器注入

前面已经说过了！

2.set方式注入（重点）

依赖注入：set注入！

依赖：bean对象的创建依赖于容器

注入：bean对象中的所有属性由容器来注入

Student实体类，其属性是不同的类型，用来测试不同类型的属性如何注入

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    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;
}

Address实体类，作为Student的引用对象

@Data
public class Address {
    private String address;
}

applicationContext.xml文件，里面有各种不同类型注入的方法

<bean id="address" class="com.drl.entity.Address">
    <property name="address" value="西安"/>
</bean>

<bean id="student" class="com.drl.entity.Student">
    <!--第一种，普通值注入，直接使用value-->
    <property name="name" value="董瑞龙"/>
    <!--第二种，bean注入，使用ref-->
    <property name="address" ref="address"/>
    <!--第三种，数组注入-->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>三国演义</value>
            <value>西游记</value>
        </array>
    </property>
    <!--List集合注入-->
    <property name="hobbys">
        <list>
            <value>弹钢琴</value>
            <value>打篮球</value>
            <value>敲代码</value>
        </list>
    </property>
    <!--Map注入-->
    <property name="card">
        <map>
            <entry key="身份证" value="0101"/>
            <entry key="学生卡" value="1010"/>
        </map>
    </property>
    <!--set注入-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>CS</value>
            <value>BOB</value>
        </set>
    </property>
    <!--null值注入-->
    <property name="wife">
        <null/>
    </property>
    <!--properties注入-->
    <property name="info">
        <props>
            <prop key="学号">19407010221</prop>
            <prop key="姓名">董瑞龙</prop>
        </props>
    </property>
</bean>

3.拓展方式注入

3.1p命名方式

需要加入p约束

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

p命名方式注入方法

 <!--p命名空间注入，可以直接注入属性-->
<bean id="user" class="com.drl.entity.User" p:name="董瑞龙" p:age="21"/>

3.2c命名方式

需要加入c约束

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

c命名方式注入方法

<!--c命名空间注入，通过构造器注入,construct-args-->
<bean id="user2" class="com.drl.entity.User" c:name="董瑞龙" c:age="21"/>

4.Bean的作用域

bean的作用域有以下5种：

singleton（单例模式）、prototype（原型模式）

request、session、application、websocket，这些只能在web中使用

4.1单例模式

单例模式是spring的默认机制，创建一个bean

<bean id="user1" class="com.drl.entity.User" scope="singleton"/>

调用两次bean，测试IOC容器到底创建了几个对象

@Test
public void test02(){
    ApplicationContext context=new ClassPathXmlApplicationContext("userbeans.xml");
    User user1 = context.getBean("user1", User.class);
    User user2 = context.getBean("user1", User.class);
    System.out.println(user1==user2);
}

测试结果为"true"
在这里插入图片描述

所以单例模式就是当调用多次bean时，IOC容器只会创建一次对象。

4.2原型模式

原型模式与单例模式相反，每次调用bean时都会创建一个新对象，测试如下：

<bean id="user1" class="com.drl.entity.User" scope="prototype"/>

@Test
public void test02(){
    ApplicationContext context=new ClassPathXmlApplicationContext("userbeans.xml");
    User user1 = context.getBean("user1", User.class);
    User user2 = context.getBean("user1", User.class);
    System.out.println(user1==user2);
}

测试结果
在这里插入图片描述

四、Bean的自动装配

bean的自动装配是spriing满足bean依赖的一种方式，spring会在上下文中寻找，并自动给bean装备属性。

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

在xml中显示的装配
在java中显示的装配
隐式的自动装配bean【重要】

1.byName自动装配

会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean的id

原先的bean需要这样创建

<bean id="dog" class="com.drl.entity.Dog"/>
<bean id="cat" class="com.drl.entity.Cat"/>
<bean id="person" class="com.drl.entity.Person">
    <property name="name" value="董瑞龙"/>
    <property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>
</bean>

通过byName自动装配后，只需要添加"autowire=byName"即可。

<bean id="dog" class="com.drl.entity.Dog"/>
<bean id="cat" class="com.drl.entity.Cat"/>
<bean id="person" class="com.drl.entity.Person" autowire="byName">
    <property name="name" value="董瑞龙"/>
</bean>

注意：如果创建cat和dog的bean的"id"与person中属性不一致，则不能通过Name自动装配！

2.byType自动装配

会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean的id

<bean id="dog" class="com.drl.entity.Dog"/>
<bean id="cat" class="com.drl.entity.Cat"/>
<bean id="person" class="com.drl.entity.Person" autowire="byType">
    <property name="name" value="董瑞龙"/>
</bean>

注意：如果IOC容器中有多个类型相同的bean，则不能通过byType进行自动装配，如下：
在这里插入图片描述

3.使用注解自动装配

3.1@Autowired

要使用注解需在spring核心配置文件中导入约束与支持：

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/cache
   http://www.springframework.org/schema/cache/spring-cache.xsd">

<context:annotation-config/>
</beans>

注解自动装配，自动配置只能给类内的引用对象类型自动装配，一般类型无法自动装配，如下图，只能给引用Dog、Cat类型自动装配。

@Autowired可以在属性上使用，也可也在set方法上使用。

自动装配注解用：@Autowire

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

3.2@Qualifier

当一个类在bean中注册多次时，自动装配无法找到准确的一个，则需要@Qualifier注解来指定具体的bean，如下：

applicationContext.xml文件

<bean id="dog1" class="com.drl.entity.Dog"/>
<bean id="dog2" class="com.drl.entity.Dog"/>
<bean id="cat1" class="com.drl.entity.Cat"/>
<bean id="cat2" class="com.drl.entity.Cat"/>
<bean id="person" class="com.drl.entity.Person" >
    <property name="name" value="董瑞龙"/>
</bean>

<context:annotation-config/>

此时自动装配报错
在这里插入图片描述

加了@Qualifier注解之后会正常

@Autowired
@Qualifier(value = "dog1")
private Dog dog;
@Autowired
@Qualifier(value = "cat1")
private Cat cat;
private String name;

五、spring注解开发

要使用注解开发，必须要导入aop依赖，可直接导入mvc依赖：

 <!--Spring webmvc依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version/>5.2.0.RELEASE</version>
    </dependency>

使用注解开发需要扫描使用注解的包，在核心配置文件中添加：

<!--扫描使用注解的包-->
<context:component-scan base-package="com.drl.entity"/>

使用注解开发还需要在核心配置文件中导入约束，一中的3.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
http://www.springframework.org/schema/context/spring-context.xsd">

<!--扫描使用注解的包-->
<context:component-scan base-package="com.drl.entity"/>
<context:annotation-config/>
</beans>

1.@Component

当创建一个实体类时需要在配置文件中写bean注入，给普通属性赋值需要用"property"标签的"value"属性实现，给对象引用类型赋值需要用”property“的"ref"属性实现。

用旧方法如下：

<bean id="dog" class="com.drl.entity.Dog"/>

<bean id="user" class="com.drl.entity.User">
    <property name="name" value="董瑞龙"/>
    <property name="dog" ref="dog"/>
</bean>

如今可以直接用@Component来注入，@Value来进行普通方法赋值，引用对象数据类型可以用@Qualifier注解，如下：

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    @Value("董瑞龙")
    private String name;
    @Autowired
    private Dog dog;
}

注意：在引用对象类型上不能直接用"@Qualifier"注解注入，只能先用"@Autowired"注解注入，若bean中有多个此类对象，则可用"@Qualifier"注解加以区分。

2.衍生的理解

@Component有几个衍生理解，在web开发时，会使用mvc三层架构分层！

controller【@controller】
service【@Service】
dao【@Repository】

这四个注解的功能都是一致的，都是代表将某个类注册到spring中，装配bean。

3.自动装配

详情见第四部分！

4.@Scope

这个注解是用配置单例模式、原型模式等等

@Component
@Scope("singleton")
public class Dog {
    public void shout(){
        System.out.println("wang~");
    }
}

六、java的配置spring

1.最大改变

用java配置spring的最大改变就是不用spring核心配置文件了，在核心配置文件中注册bean可以用java形式注入，其他的注解形式没有太大变化，如下：

之前使用xml配置文件的方法注入bean

<bean id="user" class="com.drl.entity.User"/>

java的方式注入bean

@Configuration
@ComponentScan("com.drl.entity")
@Import(myConfig2.class)
public class myConfig {
    //注册一个bean，就相当于之前写的bean标签
    //这个方法中的名字就相当于bean标签中的id属性
    @Bean
    public User getUser(){
        return new User();
    }
}

2.示例

实体类User

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
    @Value("董瑞龙")
    private String name;
}

config类（用java代替xml的核心）

如果有两个config文件，则可以用@import注解进行导入

可以使用"@ComponentScan"注解进行扫描包

方法的名字就相当于bean标签中的id

@Configuration
@ComponentScan("com.drl.entity")
@Import(myConfig2.class)
public class myConfig {
    //注册一个bean，就相当于之前写的bean标签
    //这个方法中的名字就相当于bean标签中的id属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类

测试类获取"context"的方法变了，如下：

public class myTest {
    @Test
    public void test01(){
        ApplicationContext context=new AnnotationConfigApplicationContext(myConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user);
    }
}

七、代理模式

1.静态代理

角色分类：

抽象角色：一般使用接口或抽象类来解决
真实角色：被代理的对象
代理角色：代理真实角色，代理真实的角色之后会做一些附属操作
客户：访问代理对象的人

静态代理可以这样形象的分析：

张三已经30岁了，家里催着结婚，但是自己身边又没有合适的人，所以就把自己的信息给了婚介所，让婚介所帮着找结婚的对象。经过几个月婚介所对人员筛选之后，终于给张三找到了一个叫做小丽的女孩子，最后他们过上了幸福美满的生活！

以上信息中，张三就是真实角色，张三的目的是想要找到一个结婚对象，但是自己又不想做”找“的这些事，所以就将自己的信息给了婚介所，婚介所就是代理角色，张三只想见面看是否合适，那么中间的一系列信息筛选流程由代理角色完成。小丽就是婚介所的客户，通过代理角色联系上了真实角色。张三的需求是给自己找对象，婚介所的需求也是给张三找对象，所以他们的目的性是一致的，故有个接口可以放两个人的共同需求。

以下是代码相关实现：

接口

public interface zhaoduixiang {
    //婚介所和张三共同的需求
    public void zhaoduixiang();
}

张三

public class zhangsan {
    //张三的需求
    public void zhaoduixiang(){
        System.out.println("张三想找结婚对象！");
    }
}

婚介所

//由于婚介所是代理角色，所以也实现了找对象的接口
@Data
@AllArgsConstructor
@NoArgsConstructor
public class hunjiesuo implements zhaoduixiang{
    
    //只有婚介所可以联系到张三，其他人也只能通过婚介所联系张三
    private zhangsan zs;

    @Override
    public void zhaoduixiang() {
        System.out.println("给张三找对象！");
    }
    //在给张三找对象期间，婚介所需要筛选不符合张三需求的人
    public void shaixuan(){
        System.out.println("婚介所筛选信息！");
    }
}

小丽

//婚介所的客户
@Data
public class xiaoli {
    public static void main(String[] args) {
        //小丽作为客户先联系到了婚介所
        hunjiesuo hunjiesuo1=new hunjiesuo(new zhangsan());
        //小丽只能通过婚介所联系到张三
        zhangsan zs = hunjiesuo1.getZs();
        //联系到张三之后，知道了张三的需求和在婚介所了解的一样
        zs.zhaoduixiang();
        //了解彼此之后，两人就幸福美满的在一起了
    }
}

2.动态代理

动态代理和静态代理角色一样，动态代理和代理类是动态生成的，不是自己写好的。

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

基于接口：JDK动态代理【使用】
基于类：cglib
基于字节码实现：Javasist

后面的没听懂，有机会继续学习！

八、AOP

1.AOP简介

在某一个系统中添加一个公共功能，此时不能将原先底层代码改动，可以横向切面进行实现。
在这里插入图片描述

2.spring实现aop

导入依赖

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

2.1使用spring接口

log包下有两个类：

AfterLog类

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

Log类

public class Log implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

service包下有一个接口和一个实现类

UserService接口

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

spring核心配置文件

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

        <bean id="log" class="com.drl.log.Log"/>
        <bean id="afterLog" class="com.drl.log.AfterLog"/>
        <bean id="userService" class="com.drl.service.UserServiceImpl"/>

    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.drl.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut1"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut1"/>
    </aop:config>
</beans>

2.2自定义类实现

自定义切面类

public class DiyPointCut {
    public void before(){
        System.out.println("=========方法执行前==========");
    }

    public void after(){
        System.out.println("=========方法执行后==========");
    }
}

配置文件

<!--方式二：自定义类-->
    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.drl.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

2.3注解实现aop

使用注解实现aop之前需要开启aop注解支持

<!--开启注解支持-->
<aop:aspectj-autoproxy/>

注解实现

//使用注解方式实现aop
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.drl.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=======方法执行前==========");
    }

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

九、整合mybatis

此处整合mybatis时将配置文件写在一块了，后面整合SSM框架时，会分为spring-mybatis.xml、spring-mvc.xml，然后在总的applicationContext.xml来引用。=，引用需要以下这个标签：

<import resource=""/>

1.导入依赖

<dependencies>
    <!--测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--mvc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <!--spring连接数据库-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <!--AOP-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
    <!--spring整合mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
</dependencies>
<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>13</source>
                    <target>13</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.配置文件

配置文件spring-mybatis.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:p="http://www.springframework.org/schema/p"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.2.xsd">



    <context:annotation-config/>
<!--    配置spring的数据源-->
    <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="drldrl521521"/>
    </bean>
    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis的配置-->
        <!--别名，扫描包的形式-->
        <property name="typeAliasesPackage" value="com.drl.entity"/>
        <!--绑定mapper-->
        <property name="mapperLocations" value="classpath:com/drl/dao/UserMapper.xml"/>
<!--        <property name="mapperLocations" value="classpath:com/drl/dao/*.xml"/>-->
    </bean>
    <!--sqlSessionTemplate:就是之前使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--使用构造器注入-->
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userMapper" class="com.drl.dao.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

3.实体类

User

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

4.Dao及Mapper

spring将mybatis结合之后，在Dao层还需实现UserMapper接口

UserMapper接口

public interface UserMapper {
    public List<User> getUser();
}

UserMapperImpl实现类

public class UserMapperImpl implements UserMapper {

    private SqlSessionTemplate sqlSessionTemplate;

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUser() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.getUser();
    }
}

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">

<!--相当于原先JDBC的实现类-->
<!--namespace需要绑定一个相应的Dao/Mapper接口-->
<mapper namespace="com.drl.dao.UserMapper">

    <select id="getUser" resultType="user">
        select * from user
    </select>
</mapper>

5.测试

public class Test {
    @org.junit.Test
    public void test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-mybatis.xml");
        UserMapperImpl userMapper = context.getBean("userMapper", UserMapperImpl.class);
        List<User> userList = userMapper.getUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }

6.整合mybatis第二种方法

将UserMapperImpl实现类中改为如下：

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List<User> getUser() {
        return getSqlSession().getMapper(UserMapper.class).getUser();
    }
}

这个方法的底层也是原先的形式，需要继承"SqlSessionDaoSupport"，可以直接得到mapper，不需要在bean中注册sqlSession，但需要将sqlSessionFactory注入其中。

spring-mybatis配置文件

<!--创建mapper2-->
<bean id="userMapper2" class="com.drl.dao.UserMapperImpl2">
    <property name="sqlSessionFactory" 				ref="sqlSessionFactory"/>
</bean>

7.可能会报错

7.1字符码问题

在这里插入图片描述

在所有的配置文件中：UserMapper.xml、spring-mybatis.xml文件中不能写有中文注释，否则会报错。去掉所有的配置文件就可以运行。

也可以将xml文件上面"UTF-8"改为"UTF8"解决这个问题。

有关文档：

spring官网：

https://docs.spring.io/spring-framework/docs/current/reference/html/

java白中白.

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
快速学习spring

spring一、spring入门1.理解IOC Dao层有一个接口UserDaopublic interface UserDao { void getUser();} 有4个实现其的类，每个类中的实现类型都不一样 UserDaoImpl实现类public class UserDaoImpl implements UserDao{ public void getUser() { System.out.println("查到数据!"); }}
复制链接

扫一扫