spring简单入门和使用，日常使用足够

最新推荐文章于 2022-07-26 13:46:01 发布

纵上丝滑

最新推荐文章于 2022-07-26 13:46:01 发布

阅读量362

点赞数

文章标签： java idea spring

本文链接：https://blog.csdn.net/qq_43750301/article/details/124491818

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
spring
总结

前言

提示：这里可以添加本文要记录的大概内容：

本人是通过B站狂神视频和官网文档学习的spring，喝水不忘挖井人，狂神的视频让我受益颇多，文章中所有代码都放在gitee仓库中（链接见文章总结），希望文章分享对大家有所帮助！

提示：以下是本篇文章正文内容，下面案例可供参考

spring

一、简介

官网：https://spring.io/projects/spring-framework

文档：https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/core.html

github: https://github.com/spring-projects/spring-framework

依赖:

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.2</version>
</dependency>

二、ioc

指控制翻转是一种设计思想，把主动权交给用户，DI（依赖注入）是实现IOC的一种方法

通过set注入的方式降低了系统耦合性

ioc实现由三种方式：属性注入、构造器注入、自动装配

**属性注入：**在配置文件中将类的属性赋值上去并且实现set方法

在xml里面配置bean和property的值

<bean id="对象名" class="类的包位置">  
    <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写 value为属性值 ref为引用类-->
    <property name="set后面部分" value="属性值"></property>  
    <property name="set后面部分" value="属性值"></property>  
</bean>

**构造器注入：**在构造器中注入依赖对象，定义有参构造器，配置xml文件

<!-- 构造器里面没有name字段，只有value，是根据构造器的方法参数顺序来定义的 -->  
<bean id="对象名" class="类包">  
    <constructor-arg value="属性值"></constructor-arg>  
    <constructor-arg value="红色"></constructor-arg>
</bean>

**自动装配：**在类前面加注解：@Component，在需要注入的类里面加注解：@Autowired

这样xml里面的自动扫描就会扫描到这些加了注解的类和属性，在实例化bean的时候，Spring容器会把加了@Component的类实例化；在实际运行时，会给加了@Autowired的属性注入对应的实例。

Spring中的自动装配有哪些限制？
1. 如果使用了构造器注入或者setter注入，那么将覆盖自动装配的依赖关系。
2. 基本数据类型的值、字符串字面量、类字面量无法使用自动装配来注入。
3. 有先考虑使用显式的装配来进行更精确的依赖注入而不是使用自动装配。
和自动装配相关的注解有哪些？
1. @Required：该依赖关系必须装配（手动或自动装配），否则将抛出BeanInitializationException异常。
2. @Autowired：自动装配，默认按类型进行自动装配。
3. @Qualifier：如果按类型自动装配时有不止一个匹配的类型，那么可以使用该注解指定名字来消除歧义。

1.在servlet中通过set方式

/**
 * 添加set和get方法，实现ioc控制反转
 * 通过set方法进行动态注入，主动权掌握在用户传递手上
 * 往常这里是直接写死，即往常是用接口对象指向将要使用的实现类，现在改为传递
 */

public class UserServletImpl implements UserServlet{

    //往常方法，直接写死要用哪个实现
//    UserDao userDao=new UserDaoMysql();

    private UserDao userDao;

    //利用set进行动态注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

实现了控制反转，即用户要用哪个，就在接口对象这直接传入哪个实现类

2.ioc创建对象两种方式

无参构造，这里就是上面的属性注入

参数名方式

<bean id="hello" class="com.zhang.pojo.Hello">
     <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写 value为属性值 ref为引用类-->
    <property name="str" value="wo shi ni die"/>
</bean

有参构造

下标赋值 index方法，下标从0开始

 <!--方法一 下标赋值-->
    <bean id="hello" class="com.zhang.pojo.Hello">
        <constructor-arg index="0" value="下标方式"/>
    </bean>

类型方式不推荐

<!--方式二 类型-->
<bean id="hello" class="com.zhang.pojo.Hello">
    <constructor-arg type="java.lang.String" value="类型方式"/>
</bean>

参数名方式

<bean id="hello" class="com.zhang.pojo.Hello">
   <!-- name指构造器传入的参数名 -->
   <constructor-arg name="str" value="参数名"/>
</bean>

三、helloSpring

1.创建一个pojo类

package com.zhang.pojo;

public class Hello {
    private String str;

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}

2.建立配置文件

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">
    
    <!--id相当于类名 class为对应的类-->
    <bean id="hello" class="com.zhang.pojo.Hello">
        <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写 value为属性值 ref为引用类-->
        <property name="str" value="wo shi ni die"/>
    </bean>


</beans>

3.测试

ApplicationContext context = new ClassPathXmlApplicationContext(“services.xml”, “daos.xml”);

加载相应的配置文件（bean.xml）

import com.zhang.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

四、配置

1.别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名，在获取Bean的时候可以使用别名获取

<!--别名-->
<alias name="hello" alias="nihao"/>

2.bean

<!--name就相当于别名 可以取多个-->
<bean id="nihao" class="com.zhang.pojo.Hello" name="hello2,hello3">
    <!--name为属性名 value为属性值 ref为引用类-->
    <property name="str" value="wo shi ni die"/>
</bean>

3.import

一般用来团队开发导入别的配置文件，这样就可以有多个配置文件

 <!--导入别的配置-->
<import resource="bean1.xml"/>

五、依赖注入

依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

1.构造注入

就是前面的有参构造（三种）

2.set注入

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

bean对象创建依赖于容器同时通过容器进行呢set传入

package com.zhang.pojo;

import java.util.Arrays;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class User {
    private int id;
    private String name;
    private Hello hello;
    private String[] aliesNames;
    private Map<String,String> cards;
    private Set<String> game;
    private Properties info;//列表

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", hello=" + hello +
                ", aliesNames=" + Arrays.toString(aliesNames) +
                ", cards=" + cards +
                ", game=" + game +
                ", info=" + info +
                '}';
    }

    public User(int id, String name, Hello hello, String[] aliesNames, Map<String, String> cards, Set<String> game, Properties info) {
        this.id = id;
        this.name = name;
        this.hello = hello;
        this.aliesNames = aliesNames;
        this.cards = cards;
        this.game = game;
        this.info = info;
    }

    public Set<String> getGame() {
        return game;
    }

    public Properties getInfo() {
        return info;
    }

    public void setGame(Set<String> game) {
        this.game = game;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Hello getHello() {
        return hello;
    }

    public void setHello(Hello hello) {
        this.hello = hello;
    }

    public String[] getAliesNames() {
        return aliesNames;
    }

    public void setAliesNames(String[] aliesNames) {
        this.aliesNames = aliesNames;
    }

    public Map<String, String> getCards() {
        return cards;
    }

    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    }



    public User() {
    }
}

<?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">
  
    <!--name就相当于别名 可以取多个-->
    <bean id="nihao" class="com.zhang.pojo.Hello" name="hello2,hello3">
        <!--name为属性名 value为属性值 ref为引用类-->
        <property name="str" value="wo shi ni die"/>
    </bean>

	<!--set注入-->
    <bean id="user1" class="com.zhang.pojo.User" >
        <!--bean注入 这里注入对象 -->
        <property name="hello" ref="nihao"/>
        <!--属性注入-->
        <property name="id" value="1"/>
        <property name="name" value="lisi"/>
        <!--数组注入-->
        <property name="aliesNames">
            <array>
                <value>铁裆</value>
                <value>王虎</value>
                <value>狗蛋</value>
            </array>
        </property>
        <!--map注入-->
        <property name="cards">
            <map>
                <entry key="ID" value="1234567890"/>
                <entry key="number" value="09876543"/>
            </map>
        </property>
        <property name="game">
            <set>
                <value>唱</value>
                <value>跳</value>
                <value>rap</value>
            </set>
        </property>
        <property name="info">
            <props>
                <prop key="学号">201820181221</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>

</beans>

list使用和数组类似

3.bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .

单例模式默认是单例也就是说在永远只存在一份即从xml中获取的都一样

<bean id="hello" class="com.zhang.pojo.Hello" scope="singleton">
        <!--name为属性名 value为属性值 ref为引用类-->
        <property name="str" value="wo shi ni die"/>
    </bean>

原型模式每次获取都会产生一个新对象
```
<bean id="hello" class="com.zhang.pojo.Hello" scope="prototype">
    
    <property name="str" value="wo shi ni die"/>
</bean>
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MdiGYi8T-1651202373207)(C:\Users\张大刀\AppData\Roaming\Typora\typora-user-images\image-20201214150054632.png)]
还有request session application

六、p命名空间 c命名空间

1.p命名

相当于properties

要多加入这句

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

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

    <bean id="hellop" class="com.zhang.pojo.Hello" p:str="p下的hello"/>



</beans>

2.c命名

同理加上如下：

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

注意使用c命名要在pojo中加入构造器

七、bean的自动装配

1.spring中装配方式有三种：

在xml显示装配
在java中显示装配
自动装配（隐式的bean发现机制）

2.自动装配

自动装配是使用spring满足bean依赖的一种方法，spring会在应用上下文中为某个bean寻找其依赖的bean。

创建三个实体类，将其中两个装配到一个类中：

Cat.java

public class Cat {
    public void shot(){
        System.out.println("maomaomao");
    }
}

Dog.java

public class Dog {
    public void shot(){
        System.out.println("wangwangwang");
    }
}

User.java

public class User {
   private Cat cat;
   private Dog dog;
   private String name;
   public Person() {
    }

    public Person(Cat cat, Dog dog, String name) {
        this.cat = cat;
        this.dog = dog;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    } 
}

两种方式：

ByName

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

<!--使用byname的方式自动装配-->
<bean id="person" class="com.zhang.pojo.Person" autowire="byName">
    <!--使用了自动装配 下面这两行就不用写了 spring会通过名字自动配置-->
    <!--<property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>-->
    <property name="name" value="真人"/>
</bean>

注意要保证bean中的id唯一并且名字要与注入类的set名一样

ByType

<bean class="com.zhang.pojo.Cat"/>
<bean class="com.zhang.pojo.Dog"/>

<!--使用bytype的方式自动装配-->
<bean id="person" class="com.zhang.pojo.Person" autowire="byType">
    <!--使用了自动装配 下面这两行就不用写了 spring会通过名字自动配置-->
    <!--<property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>-->
    <property name="name" value="真人"/>
</bean>

注意要保证bean中class唯一并且类型要与注入类的一样

3.使用注解自动装配

@Autowired
1. @Autowired是按类型自动转配的，不支持id匹配。
2. required=false是设置可以为空
3. 专门指定装配的类 @Qualifier(value = “dog”)

导入约束

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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="cat" class="com.zhang.pojo.Cat"/>
    <bean id="dog" class="com.zhang.pojo.Dog"/>
    <bean id="person" class="com.zhang.pojo.Person" />

</beans>

直接在注入类的属性上使用 @Autowired

同时set方法可以省略

//  required=false是设置可以为空 直接用@Autowired相当于byType方式自动装配
    @Autowired(required = false)
    private Cat cat;

    @Autowired
//  专门指定装配的类 相当于byName的方式来自动装配
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;

@Qualifier
1. @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
2. @Qualifier不能单独使用，即要配合@Autowired使用。
@Resource

也可使用java原生注解 @Resouce 可以通过name=“” 来指定
它会先通过名字匹配如果没有则通过类型匹配
使用@Resource要导依赖

<!--用来支持@Resource注解-->
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

Boy.java

package com.zhang.pojo;

public class Boy {

    private String name;

    public Boy(String name) {
        this.name = name;
    }

    public Boy() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Gril.java

package com.zhang.pojo;


public class Gril {

    private String name;

    public Gril() {
    }

    public Gril(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

bean2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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="boy" class="com.zhang.pojo.Boy">
        <property name="name" value="大刀"/>
    </bean>
    <bean id="gril" class="com.zhang.pojo.Gril">
        <property name="name" value="小刀"/>
    </bean>
    <bean id="family" class="com.zhang.pojo.Family"/>

</beans>

Family.java

package com.zhang.pojo;
import javax.annotation.Resource;
public class Family {
    @Resource
    private Boy boy;

    @Resource(name = "gril")
    private Gril gril;

    private String familyName;

    public Family() {
    }

    public Family(Boy boy, Gril gril, String familyName) {
        this.boy = boy;
        this.gril = gril;
        this.familyName = familyName;
    }

    public Boy getBoy() {
        return boy;
    }

    public void setBoy(Boy boy) {
        this.boy = boy;
    }

    public Gril getGril() {
        return gril;
    }

    public void setGril(Gril gril) {
        this.gril = gril;
    }

    public String getFamilyName() {
        return familyName;
    }

    public void setFamilyName(String familyName) {
        this.familyName = familyName;
    }

    @Override
    public String toString() {
        return "Family{" +
                "boy=" + boy +
                ", gril=" + gril +
                ", familyName='" + familyName + '\'' +
                '}';
    }
}

@Test
public void pertestBean2Family(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    Family family = context.getBean("family", Family.class);
    System.out.println(family.toString());

}

4.@Autowired与@Resource异同

@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。
@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用
@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

八、注解开发

注解说明：

@Autowired:自动装配通过类型名字

如果它不能自动装配则需要@Qualifier(value=xxx)
@Nullable:字段标记了这个注解说明这个注解能为null
@Resource:自动装配（原生的）通过名字类型
@Component: 组件放在类中说明这个类被spring管理了就是bean

**注意：**在使用之前要添加约束

特别要注意扫描包的最好将文件命名为applicationContest.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"
       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:component-scan base-package="com.zhang.pojo"/>
    <!--开启注解支持-->
    <context:annotation-config/>

</beans>

1.@Component

组件放在类中说明这个类被spring管理了就是bean

//这里的@Component组件 相当于<bean id="user" class=“com.zhang.pojo.User"/>
//相当于@Component("user")
@Component
public class User {
    public String name="dadao";
}

2.@Value

简单值的注入放在set方法中也行

//相当于<property name="name" value="令狐冲"/>
@Value("令狐冲")
public String name;

3.衍生注解

@Component的衍生注解会在MVC中分层

dao @Repository
servlet @Servlet
controller @Controller

这四个功能都是一样的代表将该类注册到spring中装配到bean

4.Scope(“singleton”)

用来设置作用域默认单例

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

package com.zhang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//这里的@Component组件 相当于<bean id="user" class=“com.zhang.pojo.User"/>
@Component
//用来设置作用域
@Scope("singleton")
public class User {

    //相当于<property name="name" value="令狐冲"/>
    @Value("令狐冲")
    public String name;
}

5.总结

一般来说

xml用来管理bean

注解只负责完成属性的注入

注意要让注解生效一定要开启注解

<!--添加扫描包-->
<context:component-scan base-package="com.zhang.pojo"/>
<context:annotation-config/>

6.使用纯java的方式配置spring

项目模块在spring-06-appconfig

编写pojo中的User.class 注意要有无参构造

package com.zhang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    private String name;


    public User() {

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    @Value("zhangdadao")
    public void setName(String name) {
        this.name = name;
    }
}

编写config中的ZhangConfig.class

package com.zhang.config;

import com.zhang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//spring容易托管 注册到容器中 @Configuration代表这个是一个配置类类似以前的bean.xml
@Configuration

//用来扫描包的
@ComponentScan("com.zhang.pojo")

//用来导入别的配置包
@Import(ZhagnConfig.class)
public class ZhagnConfig {

    //注册一个bean 方法名相当于id
    @Bean
    public User getUser(){
        return new User();
    }
}

编写测试 注意这里的获取context方式和原来不一样

import com.zhang.config.ZhagnConfig;
import com.zhang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //使用注解类方式 则用下面这个类获取
        ApplicationContext context = new AnnotationConfigApplicationContext(ZhagnConfig.class);
        //这里获取的bean名和注册方法名一样
        User user = context.getBean("getUser",User.class);
        System.out.println(user.toString());

    }
}

九、代理模式

1.静态代理

本质就是对原有功能的封装和增强

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现
真实角色 : 被代理的角色
代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
客户 : 使用代理角色来进行一些操作 .

代码实现

Rent . java 即抽象角色

//抽象角色：租房
public interface Rent {
   public void rent();
}

Host . java 即真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

Proxy . java 即代理角色

/**
 * 代理角色
 * 1、要实现接口
 * 2、要有真实角色作为私有属性，从而调用真是角色的功能
 * 3、可以扩展新的功能
 * 4、让用户调用代理接口从而达到代理的目的
 */
public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        fare();
    }

    //这两个就相当代理中对方法的功能的增加
    public void seeHouse(){
        System.out.println("带房客看房子");
    }
    public void fare(){
        System.out.println("中介收费");
    }
}

Client . java 即客户

/**
 * 客户类 使用代理
 */
public class Client {
    public static void main(String[] args) {
        Host host = new Host();//真实角色
        Proxy proxy = new Proxy(host);//代理角色
        proxy.rent();//使用代理
    }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，相当于中间进行了封装的功能增强

静态代理的好处:

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .

缺点 :

类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

巩固练习：

1、创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！

//抽象角色：增删改查业务
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

2、我们需要一个真实对象来完成这些增删改查操作

//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {

   public void add() {
       System.out.println("增加了一个用户");
  }

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

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

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

3、需求来了，现在我们需要增加一个日志功能，怎么实现！

思路1 ：在实现类上增加代码【麻烦！】
思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！

4、设置一个代理类来处理日志！代理角色

//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
   private UserServiceImpl userService;

   public void setUserService(UserServiceImpl userService) {
       this.userService = userService;
  }

   public void add() {
       log("add");
       userService.add();
  }

   public void delete() {
       log("delete");
       userService.delete();
  }

   public void update() {
       log("update");
       userService.update();
  }

   public void query() {
       log("query");
       userService.query();
  }

   public void log(String msg){
       System.out.println("执行了"+msg+"方法");
  }

}

5、测试访问类：

public class Client {
   public static void main(String[] args) {
       //真实业务
       UserServiceImpl userService = new UserServiceImpl();
       //代理类
       UserServiceProxy proxy = new UserServiceProxy();
       //使用代理类实现日志功能！
       proxy.setUserService(userService);

       proxy.add();
  }
}

其中的思想：在不改变原来的代码的情况下，实现了对原有功能的增强和封装，这是AOP中最核心的思想

2.动态代理

动态代理的角色和静态代理的一样 .
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理–cglib
- 现在用的比较多的是 javasist 来生成动态代理
- 这里使用JDK的原生代码来实现

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy ，打开JDK帮助文档看看

【InvocationHandler：调用处理程序】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6sbIMRvY-1651202373210)(D:\program files\Typora\home\image\640.png)]

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8iKKhCLU-1651202373213)(D:\program files\Typora\home\image\640-16509619145321.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FltoDN75-1651202373215)(D:\program files\Typora\home\image\640-16509619145322.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vxv0MnqX-1651202373216)(D:\program files\Typora\home\image\640-16509619145333.png)]

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

代码实现

抽象角色和真实角色和之前的一样！

Rent . java 即抽象角色

//抽象角色：租房
public interface Rent {
   public void rent();
}

Host . java 即真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   public void setRent(Rent rent) {
       this.rent = rent;
  }

   //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }

   // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
   // 处理代理实例上的方法调用并返回结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       seeHouse();
       //核心：本质利用反射实现！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }

}

Client . java

//租客
public class Client {

   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setRent(host); //将真实角色放置进去！
       Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
       proxy.rent();
  }

}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！、

深化理解

我们来使用动态代理实现代理我们后面写的UserService！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

package com.zhang.demo04;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 动态实现类 这里大部分都写死了
 * 只用修改代理类中的处理程序和添加新的功能方法即可
 */
public class ProxyInvocationHandler implements InvocationHandler {

    //将要传递的真实类
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成代理类  通过真实类生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    //proxy：代理类
    //method：代理类中调用处理程序的方法对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }
}

测试！

public class Test {
   public static void main(String[] args) {
       //真实对象
       UserServiceImpl userService = new UserServiceImpl();
       //代理对象的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setTarget(userService); //设置要代理的对象
       UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
       proxy.delete();
  }
}

测试，增删改查，查看结果！

3.动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

十、aop

1.定义

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

即 Aop 在不改变原有代码的情况下 , 去增加新的功能 .

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WHcGVWUG-1651202373217)(D:\program files\Typora\home\image\640.png)]

Aop在Spring中的作用

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

以下名词需要了解下：

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dTgQRJs5-1651202373218)(D:\program files\Typora\home\image\640-16510563678711.png)]

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CleDaJGc-1651202373219)(D:\program files\Typora\home\image\640-16510563678712.png)]

2.实现方式（三种）

使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

方式一（Spring API）

首先编写我们的业务接口和实现类

public interface UserService {

   public void add();

   public void delete();

   public void update();

   public void search();

}
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 search() {
       System.out.println("查询用户");
  }
}

然后去写我们的增强类(增加的功能类) , 我们编写两个 , 一个前置增强一个后置增强

package com.zhang.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
/**
 * 方法执行前增加类 对方法执行前一些功能的处理
 */
public class BeforeLog implements MethodBeforeAdvice {
    //method：要执行目标对象的方法
    //args：被调用执行方法的参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行了");
    }
}

package com.zhang.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
/**
 * 方法执行后增强
 */
public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被调用的方法
    //args 被调用的方法的对象的参数
    //target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+target.getClass().getName()+"的"+method.getName()+"方法，返回值为"+returnValue);
    }
}

最后去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: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">

    <!--注册bean-->
    <bean id="userService" class="com.zhang.service.UserServiceImp"/>
    <bean id="afterLog" class="com.zhang.log.AfterLog"/>
    <bean id="beforeLog" class="com.zhang.log.BeforeLog"/>

    <!--对aop进行配置 方式一-->
    <aop:config>
        <!--切入点 expression：表达式要匹配的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.zhang.service.UserServiceImp.*(..))"/>
        <!--执行循环环绕 advice-ref：执行方法  pointcut-ref：切入方法  这里不用在意顺序，在执行方法中已经设置了执行顺序-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试

import com.zhang.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService usrService = (UserService) context.getBean("userService");
        usrService.add();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

注意：不要有多余的依赖

方式二（自定义类）

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

package com.zhang.diy;

public class DiyPointcut {
    public void before(){
        System.out.println("---------方法执行前---------");
    }
    public void after(){
        System.out.println("---------方法执行后---------");
    }
}

在spring中配置

<!--方式二-->
<!--注册bean-->
<bean id="diy" class="com.zhang.diy.DiyPointcut"/>
<aop:config>
    <!--第二种方式：使用AOP的标签实现-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(* com.zhang.service.UserServiceImp.*(..))"/>
        <!--这里配置执行顺序-->
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

测试：

import com.zhang.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService usrService = (UserService) context.getBean("userService");
        usrService.add();
    }
}

方式三（使用注解）

第一步：编写一个注解实现的增强类

package com.kuang.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
   @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void before(){
       System.out.println("---------方法执行前---------");
  }

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

   @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void around(ProceedingJoinPoint jp) throws Throwable {
       System.out.println("环绕前");
       System.out.println("签名:"+jp.getSignature());
       //执行目标方法proceed
       Object proceed = jp.proceed();
       System.out.println("环绕后");
       System.out.println(proceed);
  }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

十一、spring-MyBatis整合

1.添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.zhang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-04-mybatis</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>true</filtering>
            </resource>

        </resources>
    </build>
</project>

2.创建pojo类

User.java

package com.zhang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

3.编写dao/mapper

UserDao.java 接口

package com.zhang.dao;

import com.zhang.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUserList();
}

相应的mapper.xml 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">

<!--name用来绑定指定的Dao/Mapper接口-->
<mapper namespace="com.zhang.dao.UserDao">

    <!--查询语句-->
    <select id="getUserList" resultType="com.zhang.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

实现接口实现将获取setSqlSession 同时将sql语句加入

package com.zhang.dao;

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

import java.util.List;

public class UserDaoImpl implements UserDao{
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> getUserList() {
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        return mapper.getUserList();
    }
}

4.配置

mybatis-config.xml 其实可有可无

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
    <!--用来扫描别名-->
    <typeAliases>
        <package name="com.zhang.pojo"/>
    </typeAliases>
</configuration>

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

    <!--获取数据源 替换原来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?characterEncoding=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"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/zhang/dao/*.xml"/>
    </bean>

    <!--就是相当于我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--这里只能通过构造器注入 因为他没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userMapper" class="com.zhang.dao.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

注意: 将sqlFactory注入sqlSession中只能通过constructor（构造）注入

5.测试

import com.zhang.dao.UserDao;
import com.zhang.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class Mytest {


    @Test
    public void testselect(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");

        UserDao userMapper = context.getBean("userMapper", UserDao.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }

    }
}

总结

在我看来spring就是一个对象的管理工厂，虽然配置麻烦了，但不可否认它简化了代码量，通过ioc和aop的应用使得代码编写更加灵活、复用。后续会更新有关springMVC的文章！
文中代码仓库为：https://gitee.com/zhangdadao/spring-study.git

纵上丝滑

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring简单入门和使用，日常使用足够

spring入门一、简介二、ioc1.在servlet中通过set方式2.ioc创建对象两种方式三、helloSpring1.创建一个pojo类2.建立配置文件3.测试四、配置1.别名2.bean3.import五、依赖注入1.构造注入2.set注入3.bean的作用域六、p命名空间 c命名空间1.p命名2.c命名七、bean的自动装配1.spring中装配方式有三种：2.自动装配3.使用注解自动装配4.@Autowired与@Resource异同八、注解
复制链接

扫一扫