Spring-IoC注解

最新推荐文章于 2023-04-02 19:40:26 发布
最新推荐文章于 2023-04-02 19:40:26 发布
阅读量130 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46060794/article/details/120299151

注解的使用

引入外部的properties文件

首先创建配置文件

 创建beans6.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">

       <bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
           <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
           <property name="url" value="jdbc:mysql://localhost:3306/maclu"></property>
           <property name="username" value="root"></property>
           <property name="password" value="123456"></property>
       </bean>
</beans>

测试

    @Test
    public void Tses15(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans6.xml");
        DruidDataSource druid = context.getBean("druid", DruidDataSource.class);
        DruidPooledConnection connection = null;
        try {
            connection = druid.getConnection();
            System.out.println(connection);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

 结果

或者先添加druid的pom依赖 

   <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.6</version>
    </dependency>

 创建beans7.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 https://www.springframework.org/schema/context/spring-context.xsd">


       <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
       <bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
           <property name="driverClassName" value="${jdbc.driverClassName}"></property>
           <property name="url" value="${jdbc.url}"></property>
           <property name="username" value="${jdbc.username}"></property>
           <property name="password" value="${jdbc.password}"></property>
       </bean>
</beans>

结果

依赖注入


1）Spring配置文件引入context约束
 

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">


</beans>

2）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"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">


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

</beans>

在classpath中的扫描组件：component-scan，他能够在classpath中自动扫描，自动检查和实例化具有特定注解的组件。

特定组件包括

  • @Component ：组件通用注解，标识一个受Spring管理的组件
  • @Controller ：常用于对表现标注
  • @Service：常用于对服务层（业务层）标注
  • @Repository：常用于对持久层标注

@Component、@Controller、@Service和@Repository功能一样，可以互换，我们使用不同注解主要为了区分被注解的类处在不同的业务层，使逻辑更加清晰。

它们使用方法：

（1）标注在类上

（2）@Component("name")等于@Component(value="user")

（3）@Component相当于@Component("className")

3）案例

Users类

package com.cqucc.pojo;

import org.springframework.stereotype.Component;

@Component
public class Users {

    private Integer userid;
    private String usernama;
    private String password;
    public Users (){
        System.out.println("这是无参构造方法");
    }

    public Users(Integer userid, String usernama, String password) {
        System.out.println("这是有参构造方法");
        this.userid = userid;
        this.usernama = usernama;
        this.password = password;
    }

    public void say(){
        System.out.println("hello");
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUsernama() {
        return usernama;
    }

    public void setUsernama(String usernama) {
        this.usernama = usernama;
    }

    public Integer getUserid() {
        return userid;
    }

    public void setUserid(Integer userid) {
        this.userid = userid;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userid=" + userid +
                ", usernama='" + usernama + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

编写测试类：

      @Test
    public void Tses(){
        ApplicationContext act = new ClassPathXmlApplicationContext("beans8.xml");
        Users users = act.getBean(Users.class);
        Users users2 = act.getBean("users",Users.class);
        System.out.println(users);
        System.out.println(users2);

    }

 测试结果

注:在注解中value属性值可以省略不写，

    @Test
    public void Tses17(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans8.xml");
        DeptAction deptAction =  context.getBean(DeptAction.class);
        System.out.println(deptAction);
        deptAction.show();
        DeptService deptService = context.getBean(DeptService.class);
        System.out.println(deptService);
        deptService.show();
        DeptDao deptDao =  context.getBean(DeptDao.class);
        System.out.println(deptDao);
    }

，首字母小写

4）属性注入 
 

4.1@Autowired

自动注入的方式进行注入，默认根据类的名称来进行装配 

DeptDao类

package com.cqucc.dao;

import org.springframework.stereotype.Repository;

@Repository
public class DeptDao {

    public void show(){
        System.out.println("dept执行了");
    }
}

DeptService 类 

package com.cqucc.service;

import com.cqucc.dao.DeptDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeptService {
    @Autowired
    private DeptDao deptDao;
    public void show(){
        System.out.println("service执行了");
        deptDao.show();
    }
}

DeptAction 类 

package com.cqucc.action;

import com.cqucc.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class DeptAction {
    @Autowired
    private DeptService deptService;
    public void show(){
        System.out.println("action执行了");
        deptService.show();
    }
}

测试类

    @Test
    public void Tses17(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans8.xml");
        DeptAction deptAction =  context.getBean(DeptAction.class);
        System.out.println(deptAction);
        deptAction.show();
        DeptService deptService = context.getBean(DeptService.class);
        System.out.println(deptService);
        deptService.show();
        DeptDao deptDao =  context.getBean(DeptDao.class);
        System.out.println(deptDao);
    }

 测试结果

@Autowired注意事项：

默认情况下，所有使用@Autowired注解的属性都需要被设置。当Spring找不到匹配的bean装配属性时，会抛出异常。

如去掉DeptAction 类中的的@Autowired时

package com.cqucc.action;

import com.cqucc.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class DeptAction {

    private DeptService deptService;
    public void show(){
        System.out.println("action执行了");
        deptService.show();
    }
}

//测试方法
    @Test
    public void Tses17(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans8.xml");
        DeptAction deptAction =  context.getBean(DeptAction.class);
        System.out.println(deptAction);
        deptAction.show();
        
    }

测试结果

4.2 @Qualifier

@Autowired是按照类型进行匹配，如果当前@Autowired标注的依赖在容器中只能找到一个实例一致对应的话，那还好。可是，要是能够同时找到多个或者同一类型的对象实例，那该怎么办？可以使用@Qualifier对依赖注入的条件做进一步限定。如下

定义接口

package com.cqucc.dao;

public interface DeptDaoInter {
    public void show();
}

实现接口的两个类

package com.cqucc.dao.Impl;

import com.cqucc.dao.DeptDaoInter;
import org.springframework.stereotype.Repository;

@Repository
public class DeptDao implements DeptDaoInter {

    public void show(){
        System.out.println("dept执行了");
    }
}

package com.cqucc.dao.Impl;

import com.cqucc.dao.DeptDaoInter;
import org.springframework.stereotype.Repository;

@Repository
public class DeptDao1 implements DeptDaoInter {

    public void show(){
        System.out.println("dept1执行了");
    }
}

测试类 

    @Test
    public void test18(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans9.xml");
        DeptService deptService = context.getBean(DeptService.class);
        System.out.println(deptService);
    }

结果：

当添加 @Qualifier（"deptDao1"）后

package com.cqucc.service;


import com.cqucc.dao.DeptDaoInter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class DeptService {
    @Autowired
    @Qualifier("deptDao1")
    private DeptDaoInter deptDaoInter;
    public void show(){
        System.out.println("service执行了");
        deptDaoInter.show();
    }
}

测试结果

4.3 @Resource

@Resource（name = "deptDao1"）相当于@Autowired+@Qualifier（"name"）

package com.cqucc.service;

import com.cqucc.dao.DeptDaoInter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class DeptService {
//    @Autowired
//    @Qualifier("deptDao1")
    @Resource(name = "deptDao1")
    private DeptDaoInter deptDaoInter;
    public void show(){
        System.out.println("service执行了");
        deptDaoInter.show();
    }
}

测试结果

 5)包含（不包含）组件

<context:component-scan>提供了两个子标签

  • <context:include-filter>
  • <context:exclude-filter>

在说明这两个子标签前，先说一下<context:component-scan>有一个use-default-filters属性，该属性默认为true，这就意味着会扫描指定包下的全部的标有Spring注解的类，并注册成bean。也就是@Component，@Controller，@Service，@Reposity等。所以如果仅仅是在配置文件中这么写

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


 use-default-filter此时为true那么会对base-package包或者子包下的所有的进行java类进行扫描,并把匹配的java类注册成bean。


可以发现这种扫描的粒度有点太大，如果你只想扫描指定包下面的Controller，该怎么办？此时子标签<context:incluce-filter>就起到了勇武之地。如下所示

        <context:component-scan base-package="com.cqucc" use-default-filters="false">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

这样就会只扫描base-package包或者子包下所有@Controller下的java类，并注册成bean。 

去访问除了@Controller以为的类会包下面的错误

如果不想扫描指定包下面的Controller时，需要使用<context:exclude-filter>标签

    <context:component-scan base-package="com.cqucc">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

去访问@Controller以为的类会包下面的错误

6)无配置注解

@Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

注意：@Configuration注解的配置类有如下要求：

@Configuration不可以是final类型；
@Configuration不可以是匿名类；
嵌套的configuration必须是静态类。

如下:

package com.cqucc.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"com.cqucc"})
public class SpringConfig {
    public SpringConfig(){
        System.out.println("容器启动初始化...");
    }
}

测试类

    @Test
    public void test20(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        DeptAction action = context.getBean(DeptAction.class);
        System.out.println(action);
        action.show();
    }

结果

spring+druid实现基于注解的多数据源切换
KGLegolas的博客
05-30 1891
数据源可以切换分为静态切换和动态切换两种，静态切换即在代码中配置多个数据源，然后为每个数据源写一套对应的sessionFactory和dao层，这样做的缺点是，在添加新的数据源时还要为新的数据源添加一个SessionFactory。使用动态切换我们只需要配置多个数据源，对应一套sessionFactory，根据需要在业务代码中实现数据源之间的动态切换。 需要注意的是spring的事务管理是基于数据...
DRUID连接池的使用
iteye_12732的博客
06-20 4192
               DRUID——为监控而生的DB池 DRUID介绍     DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池(据说是目前最好的连接池,不知道速度有没有BoneCP快)。   ...
纯注解的整合方式SSM
weixin_53805188的博客
04-12 4745
1.注解整合思路: application-mapper.xml配置文件中配置的内容包含以下4项。 读取jdbc.properties文件中的数据连接信息。 创建Druid对象，并将读取的数据连接信息注入到Druid数据连接池对象中。 创建SqlSessionFactoryBean对象，将并将Druid对象注入到SqlSessionFactoryBean对象中。 创建MapperScannerConfigurer对象，并指定扫描的Mapper的路径。 ...
SpringBoot配置数据源
热门推荐
光着脚丫、走的专栏
03-02 2万+
SpringBoot配置数据源数据源使用的是阿里的Driud。1.配置之前 先看一下xml的配置。 -------------------spring-mybatis.xml文件-------------------------- <!-- 引入属性文件 --> <context:property-placeholder location="classpath:config.properties"
alibaba druid 在springboot start autoconfig 下的bug
dengzai7446的博客
07-08 624
alibaba druid 在springboot start autoconfig下的bug 标签（空格分隔）：druid springboot start autoconfig 背景 发现、分析过程 总结 背景 最近在使用alibaba druid进行多数据源连接的时候无意中发现一个小bug，已经提交github issue 官方已经fix。issue 地址：https://g...
druid参考配置
weixin_34102807的博客
02-28 289
以下是一个参考的连接池配置： <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> <!-- 基本属性 url、user、password --> <propert...
coco-spring-ioc
04-16
6. **注解驱动的配置**：Spring-ioc也支持使用注解来替代XML配置，如`@Component`、`@Autowired`等。通过分析“coco-spring-ioc”的源码，我们可以学习如何实现类似的注解驱动的配置机制。 7. **Bean的生命周期管理...
spring-demo10-注解-IOC.zip
08-08
"spring-demo10-注解-IOC.zip"这个压缩包文件很显然包含了关于Spring框架如何使用注解进行依赖注入的示例代码。接下来，我们将深入探讨Spring中的注解和依赖注入。 依赖注入（DI）是一种设计模式，它允许我们解耦...
Spring-Ioc-注册
最新发布
01-28
Spring框架中的Ioc（控制反转）容器是整个Spring框架的核心，它负责创建对象，管理对象（包括对象的配置和依赖注入），并将这些对象连接在一起成为应用程序。Ioc容器的工作方式是通过组件和容器的概念来实现的，其中...
spring-ioc源码分析
01-10
Spring IoC容器加载Bean的配置信息主要分为两类：基于XML的配置和基于注解的配置。在基于XML的配置中，开发者需要在XML文件中声明Bean的定义信息，包括Bean的类路径、属性、构造器参数以及依赖关系等。当Spring容器...
Spring-IOC丐版
02-26
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IOC）特性而闻名。在这个名为"Spring-IOC丐版"的项目中，我们将深入探讨...
DruidDataSource数据源配置详解
06-29
可以帮助你了解,以及配置实现DruidDataSource数据源的配置
关于DruidDataSource与spring bean注入
weixin_43814165的博客
09-13 591
hive的jdbc与spring的bean注入
DruidDataSource常用配置
努力让明天变更好
03-21 1174
DruidDataSource通用配置 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> <!-- 数据源驱动类可不写，Druid默认会自动根据URL识别DriverClass --&g...
Druid 详细搭建案例
qq_41858479的博客
03-25 678
Druid配置 1.什么是druid? Druid是一个数据库连接池。Druid是目前用户的比较多的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池.同时Druid提供的监控功能，监控SQL的执行时间、ResultSet持有时间、返回行数、更新行数、错误次数、错误堆栈信息，可以清楚知道连接池和SQL的工作情况，能够详细统计SQL的执行性能，这对于线上分析数据库访问性能有...
Druid的配置和使用
weixin_54097396的博客
04-02 310
Druid的配置和使用
SpringBoot自定义方式整合Druid数据源
越努力越幸运的博客
09-17 513
文章目录SpringBoot自定义方式整合Druid数据源1、导入Druid数据源2、配置Druid的监控页，开启SQL监控3、开启防火墙4、开启Web应用模块5、配置监控页面的账号密码 SpringBoot自定义方式整合Druid数据源 1、导入Druid数据源 导入依赖： <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId>
SpringBoot-属性绑定和bean属性校验
maohe的博客
11-12 1092
属性绑定，属性校验，使用yml文件进行属性绑定，为自定义类或第三方bean进行属性绑定。松散绑定说明。
SpringBoot-24-整合持久层-自定义整合DruidDataSource数据源
时光
08-23 734
SpringBoot-24-整合持久层-自定义整合DruidDataSource数据源
深入理解Spring-MVC、Spring-IOC与Spring-JdbcTemple的实践应用
根据提供的信息，您需要了解的知识点主要涉及Spring框架的一部分，具体为Spring-MVC、Spring-IOC（控制反转）以及Spring-JdbcTemple（JDBC模板）。以下是这三个技术点的详细解释和它们在实际开发中的应用。 **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值