Spring笔记

最新推荐文章于 2025-05-27 16:06:36 发布
最新推荐文章于 2025-05-27 16:06:36 发布
阅读量272 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA框架学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lucylala007/article/details/108422463

Spring–概述

spring的优势

方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

AOP编程的支持
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付

声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。

降低JavaEE API的使用难度
Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。

spring的体系结构

在这里插入图片描述

Spring–IoC的概念和作用

什么是程序的耦合

在这里插入图片描述

在这里插入图片描述

解决程序耦合的思路

在这里插入图片描述

工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

package com.itheima.factory;

/**
 * @author Coner007
 * @creat 2020-09-04-14:54
 */

import jdk.internal.util.xml.impl.Input;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 一个创建Bean对象的工厂
 *
 * Bean:在计算机英语中，有可重用组件的含义
 * JavaBean：用java语言编写的可重用组件。
 *      javaBean > 实体类
 *
 *    他就是创建我们的service和dao 对象的。
 *
 *    第一个:需要一个配置文件来配置我们的service和dao
 *          配置的内容：唯一标识=全限定类名(key=value)
 *    第二个:通过读取配置文件中配置的内容，反射创建对象
 *
 *    我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {

    //定义一个Properties对象

    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们称之为容器

    private static Map<String,Object> beans;

    static{
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //存入容器
                beans.put(key,value);
            }
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化propertiees文件失败");
        }
    }

    /**
     * 根据Bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){

        return beans.get(beanName);
    }
}

控制反转-Inversion Of Control

在这里插入图片描述

在这里插入图片描述

Spring–使用IOC解决程序耦合

基于XML的配置

准备spring的开发包

在这里插入图片描述
pom.xml中导入jar包

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>day01_03spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.12.RELEASE</version>
        </dependency>
    </dependencies>

</project>

在类的根路径下创建一个任意名称的xml文件（不能是中文）

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

让spring管理资源，在配置文件中配置service和dao

在这里插入图片描述
测试是否配置成功

    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //根据id获取Bean对象
        AccountService as = (AccountService)ac.getBean("accountService");
        AccountDao adao = ac.getBean("accountDao",AccountDao.class);
        as.saveAccount()
        System.out.println(as);
        System.out.println(adao);

    }

在这里插入图片描述
Spring基于XML的IOC细节

spring中工厂的类结构图
在这里插入图片描述
在这里插入图片描述

BeanFactory和ApplicationContext的区别

在这里插入图片描述
ApplicationContext接口的实现类

在这里插入图片描述

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

    <!--把对象的创建交给spring来管理-->
    <!--spring对bean的管理细节
        1.创建bean的三种方式
        2.bean对象的作用范围
        3.bean对象的生命周期
    -->

    <!--创建Bean的三种方式 -->
    <!-- 第一种方式：使用默认构造函数创建。
            在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

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

    <!-- 第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    -->

    <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
    <bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
    -->

    <!-- bean的作用范围调整
        bean标签的scope属性：
            作用：用于指定bean的作用范围
            取值： 常用的就是单例的和多例的
                singleton：单例的（默认值）
                prototype：多例的
                request：作用于web应用的请求范围
                session：作用于web应用的会话范围
                global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

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

    <!-- bean对象的生命周期
            单例对象
                出生：当容器创建时对象出生
                活着：只要容器还在，对象一直活着
                死亡：容器销毁，对象消亡
                总结：单例对象的生命周期和容器相同
            多例对象
                出生：当我们使用对象时spring框架为我们创建
                活着：对象只要是在使用过程中就一直活着。
                死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收
     -->
    <bean id="accountService" class="com.itheima.service.Impl.AccountServiceImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

在这里插入图片描述

在这里插入图片描述

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

    <!-- spring中的依赖注入
    依赖注入：
        Dependency Injection
    IOC的作用：
        降低程序间的耦合（依赖关系）
    依赖关系的管理：
        以后都交给spring来维护
    在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
    依赖关系的维护：
        就称之为依赖注入。
     依赖注入：
        能注入的数据：有三类
            基本类型和String
            其他bean类型（在配置文件中或者注解配置过的bean）
            复杂类型/集合类型
         注入的方式：有三种
            第一种：使用构造函数提供
            第二种：使用set方法提供
            第三种：使用注解提供（明天的内容）
 -->


    <!--构造函数注入：
        使用的标签:constructor-arg
        标签出现的位置：bean标签的内部
        标签中的属性
            type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
            name：用于指定给构造函数中指定名称的参数赋值                                        常用的
            =============以上三个用于指定给构造函数中哪个参数赋值===============================
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

        优势：
            在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
        弊端：
            改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。
    -->

    <bean id="accountService" class="com.itheima.service.Impl.AccountServiceImpl">
        <constructor-arg name="name" value="故里"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

<!--&lt;!&ndash;    &lt;!&ndash; 配置一个日期对象 &ndash;&gt;&ndash;&gt;-->
    <bean id="now" class="java.util.Date"></bean>



    <!-- set方法注入                更常用的方式
        涉及的标签：property
        出现的位置：bean标签的内部
        标签的属性
            name：用于指定注入时所调用的set方法名称 只关注set方法名称 而不关注属性名称 如setName方法值就是name去掉set并且小写
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
        优势：
            创建对象时没有明确的限制，可以直接使用默认构造函数
        弊端：
            如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
    -->
    <bean id="accountService2" class="com.itheima.service.Impl.AccountServiceImpl2">
        <property name="name" value="长安" ></property>
        <property name="age" value="24"></property>
        <property name="birthday" ref="now"></property>
    </bean>


    <!-- 复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签：
            list array set 三者可以互换使用
        用于个Map结构集合注入的标签:
            map  props  二者可以互换使用
        结构相同，标签可以互换
    -->
    <bean id="accountService3" class="com.itheima.service.Impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>666</value>
                <value>777</value>
                <value>888</value>
            </set>
        </property>

        <property name="myMap">
            <map>
                <entry key="1" value="AAA"></entry>
                <entry key="2" value="BBB"></entry>
                <entry key="3" value="CCC"></entry>
            </map>
        </property>

        <property name="myProps">
            <props>
                <prop key="testA">aaa</prop>
                <prop key="testB">bbb</prop>
                <prop key="testC">ccc</prop>
            </props>
        </property>
    </bean>
<!--    <bean id="accountService" class="com.itheima.service.Impl.AccountServiceImpl"></bean>-->

</beans>

package com.itheima.ui;

import com.itheima.service.AccountService;
import com.itheima.service.Impl.AccountServiceImpl;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

/**
 * @author Coner007
 * @creat 2020-09-04-14:48
 */
public class Client {

    /**
     * 获取spring的Ioc核心容器，并根据id获取对象
     * @param args
     * ApplicationContext的三个常用实现类
     *      ClassPathXmlAplicationContext:它可以加载类路径下的配置文件，要求配置文件，要求配置文件必须在类路径下。不在的话，加载不了
     *      FileSystemXmlApplicationContext:它可以加载磁盘任意路径下的配置文件(必须有访问权限)
     *
     *      AnnotationConfigApplicationContext:它是用于读取注解创建容器的。
     * 核心容器的两个接口引发出的问题
     * ApplicationContext:   单例对象适用       更多的是采用此接口
     *      它在构建核心容器是，闯将对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
     * BeanFactory：         多例对象适用
     *      它在构建核心容器是，创建对象采取的策略是采用延迟加载的方式，也就是说，什么时候id获取对象了，什么时候才真正的创建对象。
     */
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //根据id获取Bean对象
        AccountService as1 = (AccountService)ac.getBean("accountService");

        as1.saveAccount();

        AccountService as = (AccountService)ac.getBean("accountService2");

        as.saveAccount();

        AccountService as2 = (AccountService)ac.getBean("accountService3");

        as2.saveAccount();
        

//       // ---------------BeanFactory----------------
//        Resource resource = new ClassPathResource("bean.xml");
//        BeanFactory factory = new XmlBeanFactory(resource);
//        AccountService as = (AccountService)factory.getBean("accountService");
//        System.out.println(as);
    }
}

Spring配置文件中提示的配置
在这里插入图片描述

spring–使用IoC的实现账户的CRUD

业务层实现类

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

    @Resource(name = "accountDao2")
    private AccountDao accountDao;

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

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

    }


}


package com.itheima.ui;


/**
 * @author Coner007
 * @creat 2020-09-04-14:48
 */
public class Client {

    /**
     * 获取spring的Ioc核心容器，并根据id获取对象
     * @param args
     * ApplicationContext的三个常用实现类
     *      ClassPathXmlAplicationContext:它可以加载类路径下的配置文件，要求配置文件，要求配置文件必须在类路径下。不在的话，加载不了
     *      FileSystemXmlApplicationContext:它可以加载磁盘任意路径下的配置文件(必须有访问权限)
     *
     *      AnnotationConfigApplicationContext:它是用于读取注解创建容器的。
     * 核心容器的两个接口引发出的问题
     * ApplicationContext:   单例对象适用       更多的是采用此接口
     *      它在构建核心容器是，闯将对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
     * BeanFactory：         多例对象适用
     *      它在构建核心容器是，创建对象采取的策略是采用延迟加载的方式，也就是说，什么时候id获取对象了，什么时候才真正的创建对象。
     */
    public static void main(String[] args) {
        //获取核心容器对象
       // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //FileSystemXmlApplicationContext ac = new FileSystemXmlApplicationContext("F:\\FreameWork\\Spring_Study\\day01_03spring\\src\\main\\resources\\bean.xml");

        //根据id获取Bean对象
        AccountService as = (AccountService)ac.getBean("accountService");

//        AccountDao adao = ac.getBean("accountDao",AccountDao.class);
//        System.out.println("adao: " + adao );
//          System.out.println(as);
        as.saveAccount();
        ac.close();
    }
}

使用注解时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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为
    context名称空间和约束中-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

</beans>

Spring–基于注解的IOC配置

常用注解

用于创建对象的：相当于：

@Component
在这里插入图片描述
@Controller @Service @Repository
在这里插入图片描述
用于注入数据的
在这里插入图片描述
@Autowired
在这里插入图片描述
@Qualifier
在这里插入图片描述
@Resource
在这里插入图片描述
@Value
在这里插入图片描述

**用于改变作用范围的：**相当于：<bean id="" class="“scope=”">

@Scope
在这里插入图片描述
和生命周期相关的：(了解)

相当于：

@PostConstruct 用于指定初始化方法。
@PreDestroy 用于指定销毁方法。

关于Spring注解和XML的选择问题

在这里插入图片描述
在这里插入图片描述
如何完全脱离xml配置文件
在这里插入图片描述

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

}

@Configuration

在这里插入图片描述
@ComponentScan
在这里插入图片描述
@Bean
在这里插入图片描述
示例代码：
在这里插入图片描述
@PropertySource
在这里插入图片描述

package config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;

/**
 * @author Coner007
 * @creat 2020-09-07-16:49
 */
//Configuration
public class JdbcConfig {

    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner creatQueryRunner(@Qualifier("ds2") DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean("ds2")
    public DataSource creatDataSource(){
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
jdbc.properties文件：jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmtest?severTimezone=UTC
jdbc.username=root
jdbc.password=123456

@Import

在这里插入图片描述

@AutoWired与@Qualifier理解
weixin_43351375的博客
09-19 7591
文章目录@[toc]@AutoWired(自动装配)@Qualifier(指定注入Bean的名称) @AutoWired(自动装配) 常用有两种模式 byName: 根据属性名自动配置 byType: 根据属性类型自动配置（Spring默认） @AutoWired自动装配默认是按类型匹配的，当且仅有一个匹配的Bean时，spring将其注入到@AutoWired标注的变量中 在Ap...
Spring注解驱动开发第20讲——使用@Autowired、@Qualifier、@Primary这三大注解自动装配组件，你会了吗？
李阿昀的博客
12-02 4725
你知道@Autowired、@Qualifier、@Primary这些注解吗？ @Autowired注解 @Autowired注解可以对类成员变量、方法和构造函数进行标注，完成自动装配的工作。@Autowired注解可以放在类、接口以及方法上。 在使用@Autowired注解之前，我们对一个bean配置属性时，是用如下XML配置文件的形式进行配置的。 <property name="属性名" value=" 属性值"/> 下面我们来看一下@Autowired注解的源码，如下所示。 这儿对@A
SpringBoot 官方文档示例：(27)通过application.properties给Map对象注入属性
amadeus_liu2的博客
04-30 2451
一、在配置类中定义Map属性 package cn.edu.tju.config; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Configuration; import java.util.HashMap; import java.util.Map; @Configuration @Configurat
Spring中@Autowired、@Qualifier、@Resource的区别
riemann_的博客
12-29 3312
1、@Autowired @Autowired 可以单独使用。如果单独使用，它将按类型装配。因此，如果在容器中声明了多个相同类型的bean，则会出现问题，因为 @Autowired 不知道要使用哪个bean来注入。因此，使用 @Qualifier 与 @Autowired 一起，通过指定bean名称来阐明实际装配的bean （按姓名连线）。如下： @Autowired() @Qualifier(...
Spring: error at ::0 can‘t find referenced pointcut的错误并解决
scruffybear的专栏
11-27 2118
运行Spring测试程序，返回错误： AOP : java.lang.IllegalArgumentException: error at ::0 can't find referenced pointcut. 需要使用更高级一点的版本的aspectjrt.jar和 aspectj-weaver.jar, 下载新版本后进行替换，问题解决。
Autowired、Resource、Qualifier的使用及区别
Jaychan的博客
01-17 573
Autowired、Resource、Qualifier的使用及区别
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
spring笔记
04-12
Spring 笔记 Spring 是 Java 企业版（Java EE）应用程序的框架，提供了结构化的配置文件，实现了控制反转（IoC）和面向切面编程（AOP），支持表现层、业务逻辑层和持久层。Spring 的核心是 IoC 和 AOP，能够与主流...
韩顺平Spring笔记
04-30
《韩顺平Spring笔记》是针对Java开发人员深入学习Spring框架的重要参考资料，它源自知名IT教育专家韩顺平的Spring教程。这篇笔记详尽地记录了Spring的核心概念、使用方法和实战技巧，对于理解Spring的工作原理和提升...
AOP——0 can‘t find referenced pointcut runTime 错误
ybb_ymm的专栏
12-30 591
自己定义了一个切面注解，及处理方法，将他打包封装后供外部调用。依赖jar包 aspectjweaver 版本 1.8.9。
spring注解Autowired和Qualifier注解的讲解。很具体
whaleluo的博客
08-18 6749
传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物，这么做有两个缺点： 1、如果所有的内容都配置在.xml文件中，那么.xml文件将会十分庞大；如果按需求分开.xml文件，那么.xml文件又会非常多。总之这将导致配置文件的可读性与可维护性变得很低。 2、在开发中在.java文件和.xml文件之间不断切换，是一件麻烦的事，同时这种思维上的不连贯也会降低开发的效率。 为...
Spring注解之 @Autowired @Qualifier
青衫客36的博客
10-14 1280
Autowired用于自动注入符合类型的 Bean。@Qualifier用于解决多个符合条件的 Bean 时的冲突，指定注入哪个 Bean。两者结合使用可以在复杂的依赖注入场景下更精确地控制 Bean 的注入。
Spring Framework系列--ApplicationContext配置标签详解（一）bean的基础标签配置
zhangzhetaojj的博客
06-10 1041
网上一直没有找到很好的博客说明，想着还是自己整合一份材料算了。。。本文的结构是以一个个小样例的形式给出，通过小样例来介绍一个个标签的作用。样例1：样例1展示了一个最简单的bean对象配置文件的写法。&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/b...
@Autowired和@Qualifie的使用
DARLING_002016的博客
03-29 858
3.创建service层的类OrderService ，要想业务层service调用实现类，通过接口调用，使用@6.如果接口下有两个实现类，那么@Autowired就找不到路径，我们就要和@Qualifie一起连用。发现报错，所以在OrderService中@Autowired下面添加@Qualifier。Autowired进行自动装配（不进行自动装配无法获取到实现类重构的方法）1.创建一个接口OrderDao ，里面写一个insert()方法。可以看到已经能够正常运行，把注解中名字改成另外一个实现类。
深入理解Spring注解：Autowired与Qualifier
最新发布
weixin_42402664的博客
05-27 909
面向切面编程（Aspect-Oriented Programming，AOP）是继OOP（面向对象编程）之后的一种编程范式，它允许将横切关注点（cross-cutting concerns），比如日志、事务管理等，与业务逻辑分离。AOP的核心概念包括切点（Pointcut）、切面（Aspect）、增强（Advice）等。使用AOP可以降低代码的复杂性，提高模块化。@Autowired注解本身具有可配置的属性，可以用于控制注入过程中的某些行为。例如，默认情况下，@Autowired。
spring error at ::0 can't find referenced pointcut解决办法
cc_百川
04-19 8304
同一段代码，每个人都有不同的错误方式。 报错提示 Exception in thread &quot;main&quot; org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userManager' defined in class path resource [applicatio...
Spring依赖注入之@Autowired、@Qualifier、@Primary、@Priority注解原理（上）
qq_32868023的博客
03-30 1613
@Autowired注解可以声明一个bean依赖的其他bean，spring在创建bean时会将这些依赖的bean注入进来，涉及到的注解有@Autowired、@Value、@Qualifier、@Primary、@Priority几个注解。@Autowired注解可以使用在Field、Constructor、Method上来注入依赖，本质上只是使用地方不同，最终都会通过AutowireCapableBeanFactory#resolveDependency方法解析出依赖的实例
SpringBoot启动时报error at ::0 can‘t find referenced pointcut XXX解决
Doge的技术小屋
11-10 1454
隐约记得这个异常在以前学Spring AOP时出现过，当时还是导的aspectweaver.jar的版本的问题，换个较新的jar包就行了(jdk版本与这个jar版本需要对应) 现在SpringBoot又出现这样的异常了，第一反应就是spring-boot-starter-aop这个依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot
使用出现aspect 出现：error at ::0 can't find referenced pointcut pt
lilei的博客
03-06 700
今天敲代码时出现如下报错 警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'saveLog' defi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值