Spring<02>IOC和DI注解开发

最新推荐文章于 2024-08-07 07:30:00 发布
最新推荐文章于 2024-08-07 07:30:00 发布
阅读量167 收藏
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45947530/article/details/103624109
版权

Spring<02>IOC和DI注解开发

1. Spring数据源

1.1 数据源（连接池）的作用（理解）

  1. 普通的JDBC连接数据库每次向数据库建立连接的时候都将connection加载到内存，再验证用户名等信息，这样会消耗一定的时间，每次的数据库连接，使用完后再断开，这样的方式会消耗大量的资源和时间。同时上千人访问的话将占用很多系统资源，导致服务器崩溃。

  2. 数据库连接池其实就是一个为数据库连接建立的一个“缓存池”,预先在数据库连接池中放入一定数量的连接。当需要数据库连接时，从连接池中拿就是了，用完再放回。数据库连接池负责分配、管理、释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立。

  3. 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中(initialPoolSize)。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。

  4. 连接池的最大数据库连接数量限定了这个连接池占有的最大连接数(maxPoolSize)。当应用程序向连接池请求的连接数超过最大连接数时，这些请求将加入到等待队列中。

  5. 数据库连接池相对于无连接池的优点

    资源重用，避免频繁创建

    事先实例化数据源，初始化部分连接资源

    提高程序的性能

    实现某一应用最大可用数据库连接数的限制避免某一应用独占所有的数据库资源
    维护连接资源：使用连接资源时从数据源获取，使用完毕后将连接归还给数据源。这样统一的连接管理，避免数据库连接泄露。

  6. 常见的数据源（连接池）：DBCP、C3P0、BoneCP、Druid等。

接下来学习数据源（第三方jar包）在Spring容器中如何实现Ioc的

学习思路：从手动创建到自动创建并注入

1.2 Spring使用数据源开发步骤（应用）*

① 导入数据源的坐标和数据库驱动坐标

② 创建数据源对象

③ 设置数据源的基本连接数据

④ 通过数据源获取连接资源和归还连接资源

1.3 手动创建数据源（理解）

1）手动创建c3p0、druid数据源并使用

① 导入c3p0、druid的坐标

<!-- 导入C3p0坐标 -->
<dependency>
	<groupId>c3p0</groupId>
	<artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
<!-- 导入druid坐标 -->
<dependency>
	<groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

导入MySql数据库驱动和junit单元测试坐标

<!-- 导入MySql数据库驱动坐标-->
<dependency>
	<groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
</dependency>
<!-- 导入Junit单元测试坐标 -->
<dependency>
	<groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

②创建c3p0数据源对象

③设置数据源的基本连接数据

④ 通过数据源获取连接和归还连接

@Test
public void test1(){
    //②创建c3p0数据源对象
	ComboPooledDataSource dataSource = new ComboPooledDataSource();
    //③设置数据源的基本连接数据
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/maven");
    dataSource.setUser("root");
    dataSource.setPassword("135246");
    
    //④通过数据源获取连接和归还连接
    Connection con = dataSource.getConnection();
    System.out.println(con);
	con.close();
}

控制台输出连接对象字符串形式地址值，表示已经成功创建连接池并获取了连接对象。

com.mchange.v2.c3p0.impl.NewProxyConnection@59a6e353

②创建druid数据源对象

③设置数据源的基本连接数据

④ 通过数据源获取连接和归还连接

@Test
public void test1(){
    //②创建druid数据源对象
    DruidDataSource dataSource = new DruidDataSource();

    //③ 设置数据源的基本连接数据
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///maven");
    dataSource.setUsername("root");
    dataSource.setPassword("135246");

    //④ 获取连接、使用并归还
    Connection con = dataSource.getConnection();
    System.out.println(con);
    con.close();
}

控制台输出连接对象字符串形式地址值，表示已经成功创建连接池并获取了连接对象。

com.mysql.jdbc.JDBC4Connection@7006c658

2）将数据源的基本连接信息抽取到配置文件以实现解耦（以c3p0为例）（应用）

① 导入c3p0、druid的坐标 - 不变

​ 导入MySql数据库驱动和junit单元测试坐标 - 不变

② 创建c3p0数据源对象 - 不变

@Test
public void test3(){
    //②创建c3p0数据源对象
	ComboPooledDataSource dataSource = new ComboPooledDataSource();
}

③ 提取数据源的基本连接信息到配置文件jdbc.properties(名字任意，格式为properties)

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/maven
jdbc.username=root
jdbc.password=135246

④ 使用java.util提供的ResourceBundle类读取properties文件内容，参数为文件基名

//使用java.util提供的ResourceBundle类读取properties文件内容，参数为文件基名
ResourceBundle rsb = ResourceBundle.getBundle("jdbc");

⑤ 从ResourceBundle对象中取得各项参数并设置进dataSource

//从ResourceBundle对象中取得各项参数并设置进dataSource
dataSource.setDriverClass(rsb.getString("jdbc.driver"));
dataSource.setJdbcUrl(rsb.getString("jdbc.url"));
dataSource.setUser(rsb.getString("jdbc.username"));
dataSource.setPassword(rsb.getString("jdbc.password"));

//获取连接，使用关闭连接
Connection conn = dataSource.getConnection();
System.out.println(conn);
conn.close();

​ 以上就是在Spring中手动注入数据源的全部内容。接下来我们会学习如何自动注入。

1.4 Spring创建并自动注入数据源（Ioc）-c3p0（应用）

​ 上面的C3P0、Druid连接池都是我们手动创建并使用的，根据创建的思路我们考虑到可以把创建交给Spring容器：

​ ① DataSource有默认无参构造，而Spring实例化Bean的最常见方式就是使用Bean的无参构造

​ ② DataSource使用set方法设置连接的基本信息，而Spring可以通过set方法进行字符串注入

这样就实现了数据源对象在Spring容器中的Ioc：

步骤如下：

① 在项目/模块pom.xml中导入Spring-context的坐标

<!-- 导入Spring-context坐标-->
<dependency>
	<groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

<!-- 导入MySql数据库驱动坐标-->
<dependency>
	<groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
</dependency>
<!-- 导入Junit单元测试坐标 -->
<dependency>
	<groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

<!-- 导入C3p0坐标 -->
<dependency>
	<groupId>c3p0</groupId>
	<artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

① 编写DataSource类，并在类中添加属性及其set方法（已经存在，不需要我们编写）

② 在Spring核心配置文件(applicationContext.xml)中添加Bean标签，关联DataSource类。

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"></bean>

③ 在Spring核心配置文件的DataSource的Bean标签下添加属性，实现自动注入

property的name属性名称通过set方法截取；因为属性值为String，所以通过value属性设置。

    <!-- 配置C3P0数据源并自动注入连接基本参数 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- property的name属性名称通过set方法截取；因为属性值为String，所以通过value属性设置 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/maven"></property>
        <property name="user" value="root"></property>
        <property name="password" value="135246"></property>
    </bean>

通过上述配置，在创建C3P0数据源对象时，连接的基本配置信息会自动注入进该数据源对象，可以直接获取连接操作数据库。

//将数据源对象创建权转交给Spring容器，并同时实现连接基本配置信息自动注入
@Test
public void test4() throws SQLException {
    //获取
    ApplicationContext ap = new ClassPathXmlApplicationContext(
        "applicationContext.xml");
    //由原来的手动newdataSource对象，变为通过ApplicationContext提供对象
    ComboPooledDataSource dataSource = (ComboPooledDataSource)ap.getBean(
        "dataSource");
    Connection conn = dataSource.getConnection();
    System.out.println(conn);
    conn.close();
}

1.5 抽取jdbc配置文件*（应用）

有关jdbc的连接基本配置信息，最好不要直接配置在Spring的配置文件中。这个时候就要把这些信息抽取出来，放在一个单独的配置文件中jdbc.properties，文件内容如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/maven
username=root
password=135246

接下来要让jdbc.properties被Spring核心配置文件applicationContext.xml文件引用，步骤如下：

首先，需要在Spring核心配置文件中引入context命名空间和约束文件路径：

​ 命名空间：xmlns:context=“http://www.springframework.org/schema/context”
​ 约束路径：http://www.springframework.org/schema/context
​ http://www.springframework.org/schema/context/spring-context.xsd

小技巧：复制并修改bean命名空间及约束文件路径即可

然后，引入properties文件，并修改DataSource注入基本参数的配置，具体如下：

<!-- 通过context命名空间的标签，导入jdbc.properties文件。classpath表示文件在类路径下 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 配置C3P0数据源并自动注入连接基本参数 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--
       property的name属性名称通过set方法截取；因为属性值为String，所以通过value属性设置
        通过${key}的方式可以从properties文件中读取key对应的值。
      -->
    <property name="driverClass" value="${jdbc.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean>

最后，使用抽取前的java代码运行即可。

//将数据源对象创建权转交给Spring容器，并同时实现连接基本配置信息自动注入
@Test
public void test4() throws Exception {
    //获取
    ApplicationContext ap = new ClassPathXmlApplicationContext(
        "applicationContext.xml");
    //由原来的手动newdataSource对象，变为通过ApplicationContext提供对象
    DataSource dataSource = ap.getBean(
        DataSource.class);
    Connection conn = dataSource.getConnection();
    System.out.println(conn);
    conn.close();
}

*上述代码中，数据源的获取方式也是我们通过代码手动从Spring容器中获取的。生产环境中，会同时将持久层配置进Spring容器，并将DataSource自动注入进持久层中。大致思路如下：

①编写持久层代码，添加DataSource属性及其set方法

② 将持久层配置进Spring核心配置文件

③ 将DataSource配置进Spring核心配置文件，同时自动注入连接基本配置信息。最后将DataSource主动注入进持久层Bean

④ 接下来可以直接在持久层中使用数据源对象进行操作

2. Spring注解开发

Spring是轻代码重配置的框架，配置比较繁重，会影响开发效率。这个时候可以通过注解开发，注解代替xml配置文件可以简化配置，提高开发效率。

不仅仅是Spring框架，注解开发目前已经是一种趋势。

2.1 Spring原始注解

注解分为原始注解和新注解，主要是从逻辑上分的，并没有实际的影响。

原始注解出现的比较早，主要用来替代标签配置的。

注解说明
@Component使用在类上，用于实例化Bean，相当于标签
@Controller使用在web层类上，用于实例化Bean。语义化的@Component
@Service使用在service层类上，用于实例化Bean。语义化的@Component
@Repository使用在dao层类上，用于实例化Bean。语义化的@Component
@Autowired使用在对象引用字段上，用于根据当前字段类型依赖注入
@Qualifier使用在对象引用字段上，结合@Autowired一起使用，用于根据名称进行依赖注入
@Resource使用在对象引用字段上，相当于@Autowired+@Qualifier，按照名称进行依赖注入
@Value使用在普通类型字段上，注入普通属性
@Scope使用在类上，标准Bean的作用范围
@PostConstruct使用在方法上，标注该方法是Bean的初始化方法
@PreDestory使用在方法上，标注该方法时Bean的销毁方法

上述注解中比较常用的是除最后两个之外的所有注解。

注意：

使用注解进行开发时，不需要在applicationContext.xml配置各种Bean了，但是需要配置组件扫描。作用是指定哪个包及其子包下的Bean需要进行扫描，以便识别使用了注解配置的类、字段和方法。

2.2 Spring注解开发 - QuicStart

1）在 ApplicationContext.xml中中引入context命名空间和约束文件，并添加组件扫描

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

2）编写UserDaoImpl类，并使用@Component进行标注，告诉Spring容器实例化该类。

@Componet("value")		其中value相当于Bean标签的id值

package com.itheima.dao;

//该接口因为不会被配置进xml文档，所以不需要添加注解
public interface UserDao{
    public void save();
}

3）编写UserServiceImpl类，并使用@Component进行标注，告诉Spring容器实例化该类。

因为UserServiceImpl类中要依赖UserDaoImpl，所以需要在前者中添加一个对象的成员变量，并提供set方法。

同时需要在成员变量上添加注解标注实现依赖注入，可以添加@Autowired+@Qualifier注解。

@Autowired				自动注入被标记属性
@Qualifier("value")		其中，value相当于Bean标签property子标签中ref的值

package com.itheima.service;

//该接口因为不会被配置进xml文档，所以不需要添加注解
public interface UserService{
    public void save();
}

package com.itheima.service.impl;

import com.itheima.dao.UserDao;
import com.itheima.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import sun.awt.SunHints;

//下面注解相当于在xml文档中进行了如下配置：
//<bean id="userService" class="com.itheima.service.impl.UserServiceImpl“/>

@Component("userService")
public class UserServiceImpl implements UserService {
    //下面注解相当于在 xml文档中进行了如下配置
    //<bean><property name="xxx" ref="userDao" /></bean>
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;

    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

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

4）在测试类或模拟Ctroller层中测试调用。

package com.itheima;

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

public class UserServiceTest {

    @Test
    public void test5(){
        ApplicationContext apc = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = apc.getBean(UserService.class);
        userService.save();
    }
}

2.3 Spring常用原始注解

1）用来完成对象实例化的注解（常用）

​ @Component 当不知道该类属于软件分层的哪一层时，使用该注解，实例化Bean

​ @Controller 使用在web层类上，用于实例化Bean。语义化的@Component，推荐使用。

​ @Service 使用在Service层上，用于实例化Bean。语义化的@Component，推荐使用。

​ @Repository 使用在Dao层上，用于实例化Bean。语义化的@Component，推荐使用。

2）用来完成依赖注入的注解（常用）

​ 使用注解方式实现依赖注入的时候，可以不为被注入的成员变量添加set方法；

​ 使用xml配置方式实现依赖注入的时候，必须为被注入的成员变量添加set方法。

​ @Autowired 按照被标注的成员变量的数据类型在Spring容器中进行匹配，如果找到一样的，就把对应的对象赋值给被标注的成员变量。但如果在Spring容器中存在符合要求的多个bean，这个时候会无法识别使用哪个bean。

​ @Qualifier(“value”) 按照beanid值(名称)在容器中进行匹配注入，需和@Autowired一起使用。

​ @Resource(name=“name”) 相当于@Autowired+@Qualifier(“value”)。name为id的值。受高版本JDK特性影响，@Resources与JDK9版本不兼容，建议使用JDK8

3）注入普通数据类型数据的注解（常用）。

​ @Value(“value”) 为被标注的成员变量注入字符串value，但是使用频率不高。

​ 这种写法结合spel来使用，写法如下：

@Value("${jdbc.driver}") 在Spring配置文件中导入Properties文件后，可以通过key(jdbc.driver)获得value值

4）bean对象作用范围的注解（常用）

​ @Scope(“value”) 用于表示Bean对象作用范围，使用频率较高。value的常用取值有prototype和singleton

5）其他注解（不常用）

​ @PostConstruct 被标注的成员方法，将成为对象的初始化方法

​ @PreDestroy 被标注的成员方法，将成为对象的销毁方法

2.4 Spring常用新注解

​ 使用原始注解不能替代Spring配置文件中全部内容，新注解可以替代如下配置：

1）非自定义的Bean的配置：例如DataSource
2）加载Properties文件的配置：<context:property-placeholder path="classpath:xxx"/>
3）Spring注解组件扫描器配置：<context:component-scan base-package=""/>
4）引入其他xml配置文件：<import resource="applicationContext-xxx.xml">

​ 针对以上4中情况，Spring提供新注解如下：

​ Spring新注解的替代思想：使用一个类（核心配置类）替代xml核心配置文件，在类上使用注解代替原来xml文件中的标签。

注解说明
@Configuration标注在特殊的指定类上，被标注的类就是Spring核心配置类
@ComponentScan(“包名”)标注在特殊的指定类上，指定组件扫描范围，效果等同于<context:component-scan base-package=“包名”/>
@Bea(“value”)标注在特殊指定类中的方法上，用于”标注“非自定的Bean，标注方式 有些特殊：Spring会将被标注方法的返回值存储在Spring容器中（不同于自定义Bean是标注在类上，实例化该类的实例；该标签是标注在方法上 ，实例对应的是方法的返回值，返回值被value接收，方法名任意）。效果等同于<bean id=“dataSource” class=“com.mchange.v2.c3p0.ComboPooledDataSource”">
@PropertySource标注在特殊指定的类上或者其@import类上，将指定的properties文件加载进Spring容器。写法为@PropertySource(“classpath:xxx.properties”)。效果等同于<context:property-placeholder path=“calsspath:xxx”/>
@import标注在特殊指定的类上，作用：将拆分出去的配置类引入到核心配置类内，写法为：@import({xxx.class, yyy.class})。 效果上等同于

零Spring配置文件代码如下：

1）创建Spring核心配置类SpringConfiguration.java，并添加对应注解

package com.itheima.config;

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

//被该注释标注后表示该类为Spring核心配置类
@Configuration

//指定组件扫描范围，相当于<context:component-scan  base-package="包名"/>
@ComponentScan("com.itheima")

//引入拆分出去的配置类，相当于<import resource="xxx.xml"/>
@Import(DataSourceConfiguration.class)
public class SpringConfiguration{

}

2）新建jdbc.properties文件，将数据源连接基本参数配置其中：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/maven
user=root
password=135246

3）创建Spring核心配置类拆分出去的数据源配置类DataSourceConfiguration.java，并添加相应注解

package com.itheima.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;


//将Properties文件加载进Spring容器，
//相当于<context:property-placeholder path="calsspath:xxx"/>
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration{
    @Value("${jdbc.driver}")
    private String driver;

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

    @Value("${user}")
    private String username;

    @Value("${password}")
    private String password;

    @Bean("dataSource")
    public DataSource getDataSource() throws Exception {
        //创建数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        //为数据源设置连接基本参数
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);

        //返回创建好的数据源
        return dataSource;
    }
}

4）在测试列中测试注解解析情况

@Test
public void test6(){
    //因为不再使用xml配置文件形式，所以应用上下文的创建对象要调整为新的
    ApplicationContext ap = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    UserService userService  = ap.getBean(UserService.class);
    userService.save();
}

注：

UserService、UserServiceImpl、UserDao、UserDaoImpl文件代码于之前一致。

3. Spring整合Junit

​ 在之前的代码中，每逢遇到使用Junit测试Spring代码，必有下面两句代码(或类似功能代码)：

ApplicationContext ap = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = ap.getBean(UserService.class);

​ 这两行代码的作用是获取Spring应用上下文，然后从上下文拿到我们想要使用的实例对象，如果不这样操作，就无法准确获取到需要的对象，会报空指针异常。

​ 上述思路明显不符合Spring核心思想Ioc的思想，所以需要调整。

3.1 Spring整合Junit思路

​ 按照Spring核心思想Ioc思想进行测试

​ 让SpringJunit负责创建Spring容器，创建的时候传入Spring核心配置文件或配置类

​ 将需要测试的Bean直接在测试类中注入

3.2 Spring集成Junit步骤

​ ① 在模块pom.xml文件中导入Spring集成Junit（Spring-test）坐标

​ ② 使用@Runwith注解替换原来的运行器

​ ③ 使用@ContextConfiguration指定配置文件或配置类

​ ④ 使用@Autowired注入需要测试的对象（测试类中有被测试类的对象作为成员变量）

​ ⑤ 创建测试方法进行测试

3.4 Spring集成Junit代码实现

​ 1）在pom.xml文件中导入Spring集成Junit（Spring-test）坐标，Spring集成Junit依赖于Junit，所以也要把后者的坐标引入

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<!-- Spring整合Junit需要依赖junit，所以要导包，并且要求Junit版本要在4.12或以上 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

2）使用@Runwith注解替换原来的运行器，标注在测试类上。

​ @Runwith本质上也是一个运行器。eg：

​ @RunWith(JUnit4.class)就是指用JUnit4来运行

​ @RunWith(SpringJUnit4ClassRunner.class)就是让测试运行于Spring测试环境

@Runwith(SpringJunit4ClassRunner.class)
public class SpringJunitTest{
    
}

3）使用@ContextConfiguration指定配置文件或配置类，标注在测试类上。

​ @ContextConfigurationSpring整合JUnit4测试时，使用该注解引入单个或多个配置文件

​ 单个文件
​ @ContextConfiguration(Locations=“classpath：applicationContext.xml”)
​ @ContextConfiguration(classes = SimpleConfiguration.class)

​ 多个文件时

​ @ContextConfiguration(locations = { “classpath:spring1.xml”, “classpath:spring2.xml” })

@Runwith(SpringJunit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml");
public class SpringJunitTest{
    
}

4）创建测试方法进行测试

​ 被标注的成员变量引用，会在Spring容器中去查找可以匹配的对象，如果找到就注入。

@Runwith(SpringJunit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml");
public class SpringJunitTest{
    
    @Autowired
    private UserService userService;
}

5）使用@Autowired注入需要测试的对象，标注在成员变量（被注入的对象）上。

​ 被标注的成员变量引用，会在Spring容器中去查找可以匹配的对象，如果找到就注入。

@Runwith(SpringJunit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml");
public class SpringJunitTest{
    
    @Autowired
    private UserService userService;
    
    @Test
    public void testUserService(){
        userService.save();
    }
}
三岁文凭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringIoC和DI注解开发
weixin_63624023的博客
09-18 181
自定义bean类,初始化对象的注解注解名称：@Component, @Controller, @Service ,@Repository[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMtgPmE1-1663514555605)(img/image-20220905231734211.png)]小结:上面的注解是作用在自定义的类上面, 容器通过扫描注解初始化bean对象存到容器中方式一: 根据类的class类型,存储bean对象。
【SSM】Spring6（七.Spring IoC注解式开发）
北极星的博客
04-06 312
假设在某个包下有很多Bean，有的Bean上标注了Component，有的标注了Controller，有的标注了Service，有的标注了Repository，现在由于某种特殊业务的需要，只允许其中所有的Controller参与Bean管理，其他的都不实例化。@Autowired注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。@Controller、@Service、@Repository这三个注解都是@Component注解的别名。
Spring注解驱动开发（一）IOC和DI
zengdongwen的博客
03-12 216
2、注解开发入门案例HelloWorld 2.1 创建Maven工程
Spring中IOC/DI注解开发及纯注解开发
m0_62912377的博客
04-27 162
Spring的注解开发是由2.0版开始支持注解，2.5版注解功能趋于完善，3.0版支持纯注解开发。Spring的注解开发便可以真正意义上简化开发
服务端配置 Quic 协议
hugang的博客
01-13 1909
【SRS QUIC】志宏: srs引入quic选型 QUIC代理服务的实现 尝鲜 部署 Nginx Quic 使用google的openssl库编译nginx quic
day2-Spring IOC 和 DI 注解开发.md
10-15
### Spring IOC与DI注解开发知识点详解 #### 一、Spring框架概述 Spring是一个开源的Java平台框架，它提供了一种全面的编程模型，并且支持从底层的数据访问/集成到应用层的服务抽象。Spring框架的核心特性包括依赖...
SpringIoC和DI注解开发.pdf
09-26
Spring IoC 和 DI 注解开发 Spring IoC 和 DI 注解开发概述 Spring IoC（Inverse of Control，控制反转）是一种软件设计模式，它将传统的控制权从应用程序转移到框架中，使得应用程序更加灵活和可扩展。DI...
spring-demo02-IOC-DI案例.zip
08-07
Spring 框架是 Java 开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IOC）特性而闻名。在这个名为“spring-demo02-IOC-DI案例”的压缩包中，我们将...
spring核心IOC以及DI
01-21
【Spring核心IOC以及DI】是Spring框架中的关键概念，它们是Spring实现控制反转（Inversion of Control，简称IOC）和依赖注入（Dependency Injection，简称DI）的基石。这两个概念是Spring框架的核心，使得应用程序的...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring框架是Java开发中最常用的轻量级框架之一，它的核心特性包括依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）。这两个概念是Spring框架的基石，极大地简化了...
quictun:基于QUIC的最简单的隧道服务
05-18
quictun 基于QUIC的最简单的隧道服务。 快速开始 下载预编译的。 QUIC Client: ./quictun-client-darwin-amd64 -l ":1935" -r "QUIC_SERVER_IP:6935" QUIC Server: ./quictun-server-darwin-amd64 -l ":6935" -t "TARGET_IP:1935" 上面的命令将为1935 / tcp建立端口转发，如下所示： 应用程序-> QUIC客户端（1935 / tcp）-> QUIC服务器（6935 / udp） ->目标服务器（1935 / tcp） 隧道化原始连接： 应用程序->目标服务器（1935 / tcp） 从源安装 $go get -u github.com/gnolizuh/quictun/client $go get -u github.c
kwik:Java中的QUIC客户端（和客户端库）实现。 支持带有“ Flupke”插件的HTTP3
04-13
QUIC客户端Java库 Kwik是Java中协议的客户端实现。 QUIC是由IETF开发的全新传输协议，它将成为新HTTP3协议的传输层。 尽管QUIC对于HTTP3而言是必需的，但它不仅仅是HTTP3的传输协议：大多数人都将QUIC视为“下一代TCP”。 它具有与TCP类似的属性，例如，提供可靠的有序流，但是在许多方面都更好： 它可以在同一QUIC连接上为多个流（同时和顺序）提供服务 它不会遭受“行头阻塞”问题的困扰 它由TLS加密和保护（不是作为单独的层，而是嵌入在协议中） 它最多只需要一次网络往返即可建立连接（TCP和TLS的结合需要更多） 如果您想了解更多关于QUIC的知识并且能够理解荷兰语，请查看我。 如果您正在寻找Java HTTP3客户端，请查看 ，它是在Kwik之上构建的。 Kwik由Peter Doornbosch维护。 最新的最伟大的总是可以在上找到。 不
quic java_QUIC 协议网络库
weixin_42356460的博客
02-21 1918
chromium-netchromium-net 是一个独立的网络库，它包含了著名的开源浏览器 Chromium 项目中网络相关的代码，包括 net 库，url 库，SSL 库，以及 Android 平台的 Java 封装等。它同时还是一个跨平台库，可以应用于 Android 等移动平台。chromium-net 库的优势：全平台支持最新版TLS。不像 OkHttp 这样依赖系统提供 SSL/TL...
QUIC代理服务的实现
evan的专栏
04-30 4210
QUIC Proxy 随着http/3的临近，quic越来越受到关注，关于quic的介绍网上有很多，这里就不做介绍了。目前，quic有两个版本Google QUIC 和 IETF QUIC，随着IETF的最终定稿，谷歌也会向其靠拢。 作为全球最大的浏览器Chrome很早以前就开始支持GQUIC（Google QUIC），并且Youtube已经开始全站应用GQUIC协议，所以本文介绍的QUIC代理服...
在Nginx中支持HTTP3.0/QUIC
YunWisdom
07-23 1899
在Nginx中支持HTTP3.0/QUIC HTTP3.0，也称作HTTP over QUIC。核心是QUIC(读音quick)协议，由Google在2015年提出的SPDY v3演化而来的新协议，传统的HTTP协议是基于传输层TCP的协议，而QUIC是基于传输层UDP上的协议，可以定义成：HTTP3.0基于UDP的安全可靠的HTTP2.0协议，主要有以下特性： 基于UDP减少了TCP三次握手及TLS握手时间 解决多路复用丢包时的线头阻塞问题 优化重传策略 流量控制 ...
QUIC协议初探
陈海峰的博客
01-09 2万+
1、QUIC介绍 （1）QUIC（Quick UDP Internet Connections）协议 是一种全新的基于UDP的web开发协议。可以用一个公式大致概括： TCP + TLS + HTTP2 = UDP + QUIC + HTTP2’s API 从公式可看出：QUIC协议虽然是基于UDP，但它不但具有TCP的可靠性、拥塞控制、流量控制等，且在TCP协议的基础上做了一
QUIC 规范
Rin的博客
03-21 2313
简介    QUIC (Quick UDP Internet Connection) 是在UDP之上实现的一种新的多路复用的并且是安全的，是为了优化HTTP/2而重新设计的语法。QUIC 是建立在几十年的传输和安全的经验上，并且是用硬件实现了一个很优秀的多功能传输。QUIC 提供了与HTTP/2相当的多路传输和流量控制，与TLS相当的安全，与TCP 相当的连接语义、可靠性以及拥塞控制。    QU...
Quic浅析
热门推荐
啊浪的博客
06-14 2万+
简介 QUIC（Quick UDP Internet Connections)基于UDP的传输层协议，提供像TCP一样的可靠性。在提高web应用性能上，可以选择在应用层使用HTTP2.0实现多路传输，在物理层使用CDN解决网络拥塞和最后一公里问题。在传输层，目前主要使用TCP，但由于TCP本身的问题（一个充满补丁的丑陋的协议），成为了限制web应用性能的一个瓶颈。 优势 避免前序包阻...
【Spring Boot】高效配置管理: 易用性与灵活性并重
最新发布
weixin_68020300的博客
08-07 1257
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
Spring入门：IOC与DI注解配置数据源详解
"这篇文档主要讲述了Spring框架中的IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）的概念，并通过注解方式来实现。文档首先提到了数据源（连接池）在Java Spring开发中的重要性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值