day2_Spring

已于 2022-09-12 13:23:05 修改
阅读量322 收藏
点赞数
分类专栏： spring 文章标签： spring mybatis java
于 2022-09-12 13:16:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68010168/article/details/126816204
版权

Spring_day02

今日目标

  • 掌握IOC/DI配置管理第三方bean
  • 掌握IOC/DI的注解开发
  • 掌握IOC/DI注解管理第三方bean
  • 完成Spring与Mybatis及Junit的整合开发

1，IOC/DI配置管理第三方bean

1.1 案例:数据源对象管理

1.1.3 实现Druid管理
步骤1:导入druid的依赖
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>
步骤2:配置第三方bean

在applicationContext.xml配置文件中添加DruidDataSource的配置

<?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">
	<!--管理DruidDataSource对象-->
    <bean class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
</beans>

说明:

  • driverClassName:数据库驱动
  • url:数据库连接地址
  • username:数据库连接用户名
  • password:数据库连接密码
  • 数据库连接的四要素要和自己使用的数据库信息一致。
步骤3:从IOC容器中获取对应的bean对象
public class App {
    public static void main(String[] args) {
       ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
       DataSource dataSource = (DataSource) ctx.getBean("dataSource");
       System.out.println(dataSource);
    }
}

  • 第三方的类指的是什么?

    DruidDataSource

  • 如何注入数据库连接四要素?

    setter注入
1.1.4 实现C3P0管理
步骤1:导入C3P0的依赖
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

对于新的技术，不知道具体的坐标该如何查找?

  • 从mvn的仓库https://mvnrepository.com/中进行搜索
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
    <property name="maxPoolSize" value="1000"/>
</bean>

注意:

  • ComboPooledDataSource的属性是通过setter方式进行注入
  • 想注入属性就需要在ComboPooledDataSource类或其上层类中有提供属性对应的setter方法
  • C3P0的四个属性和Druid的四个属性是不一样的
步骤3:运行程序

程序会报错，错误如下

报的错为ClassNotFoundException,翻译出来是类没有发现的异常，具体的类为com.mysql.jdbc.Driver。错误的原因是缺少mysql的驱动包。只需要在pom.xml把驱动包引入即可。

注意：
  • 数据连接池在配置属性的时候，除了可以注入数据库连接四要素外还可以配置很多其他的属性，具体都有哪些属性用到的时候再去查，一般配置基础的四个，其他都有自己的默认值
  • Druid和C3P0在没有导入mysql驱动包的前提下，一个没报错一个报错，说明Druid在初始化的时候没有去加载驱动，而C3P0刚好相反
  • Druid程序运行虽然没有报错，但是当调用DruidDataSource的getConnection()方法获取连接的时候，也会报找不到驱动类的错误

1.2 加载properties文件

1.2.1.2 实现步骤
步骤1:准备properties配置文件

resources下创建一个jdbc.properties文件,并添加对应的属性键值对

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root
步骤2:开启context命名空间

在applicationContext.xml中开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"
       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">
</beans>
步骤3:加载properties配置文件

在配置文件中使用context命名空间下的标签来加载properties配置文件

<context:property-placeholder location="jdbc.properties"/>
步骤4:完成属性注入

使用${key}来读取properties配置文件中的内容并完成属性注入

 <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>
1.2.2.3 注意事项

  • 问题一:键值对的key为username引发的问题

    1.在properties中配置键值对的时候，如果key设置为username，运行后，在控制台打印的却不是root666，而是自己电脑的用户名

    username=root666

    2.出现问题的原因是<context:property-placeholder/>标签会加载系统的环境变量，而且环境变量的值会被优先加载，如何查看系统的环境变量?

    public static void main(String[] args) throws Exception{
    Map<String, String> env = System.getenv();
    System.out.println(env);
}

    3.解决方案

     <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

    system-properties-mode:设置为NEVER,表示不加载系统属性，就可以解决上述问题。

    当然还有一个解决方案就是避免使用username作为属性的key。

  • 问题二:当有多个properties配置文件需要被加载，该如何配置?
     <!--方式一 -->
    <context:property-placeholder location="jdbc.properties,jdbc2.properties" system-properties-mode="NEVER"/>
    <!--方式二-->
    <context:property-placeholder location="*.properties" system-properties-mode="NEVER"/>
    <!--方式三 -->
    <context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>
    <!--方式四-->
    <context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>
</beans>

    说明:

    • 方式一:可以实现，如果配置文件多的话，每个都需要配置
    • 方式二:*.properties代表所有以properties结尾的文件都会被加载，可以解决方式一的问题，但是不标准
    • 方式三**:标准的写法，classpath:代表的是从根路径下开始查找，但是只能查询当前项目的根路径**
    • 方式四:不仅可以加载当前项目还可以加载当前项目所依赖的所有项目的根路径下的properties配置文件

1660711715985

1.2.3 加载properties文件小结
  • 如何开启context命名空间

1660734357836

  • 如何加载properties配置文件

    <context:property-placeholder location="" system-properties-mode="NEVER"/>

  • 如何在applicationContext.xml引入properties配置文件中的值

    ${key}

2，核心容器

2.2.1 容器的创建方式
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

这种方式翻译为:类路径下的XML配置文件

ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");

这种方式翻译为:文件系统下的XML配置文件

2.2.2 Bean的三种获取方式

方式一：每次获取的时候都需要进行类型转换

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

方式二：可以解决类型强转问题，但是参数又多加了一个

BookDao bookDao = ctx.getBean("bookDao"，BookDao.class);

方式三:类似依赖注入中的按类型注入。必须要确保IOC容器中该类型对应的bean对象只能有一个。

BookDao bookDao = ctx.getBean(BookDao.class);
2.2.3 容器类层次结构

1660734485775

2.2.4 BeanFactory的使用

使用BeanFactory来创建IOC容器的具体实现方式为:

public class AppForBeanFactory {
    public static void main(String[] args) {
        Resource resources = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resources);
        BookDao bookDao = bf.getBean(BookDao.class);
        bookDao.save();
    }
}

  • BeanFactory是延迟加载，只有在获取bean对象的时候才会去创建

  • ApplicationContext是立即加载，容器加载的时候就会创建bean对象

  • ApplicationContext要想成为延迟加载，只需要按照如下方式进行配置

     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"  lazy-init="true"/>

2.2 核心容器总结

2.2.1 容器相关

  • BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
  • ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
  • ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
  • ApplicationContext接口常用初始化类
    • ClassPathXmlApplicationContext(常用)
    • FileSystemXmlApplicationContext
2.2.2 bean相关

1660734562589

2.2.3 依赖注入相关

1660734580214

3，IOC/DI注解开发

3.2 注解开发定义bean

1、在BookDaoImpl类上添加@Component注解

@Component("bookDao")
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ..." );
    }
}

注意:@Component注解不可以添加在接口上，因为接口是无法创建对象的。

XML与注解配置的对应关系:

1660734671434

步骤3:配置Spring的注解包扫描

为了让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">
    <context:component-scan base-package="com.itheima"/>
</beans>

说明:

component-scan

  • component:组件,Spring将管理的bean视作自己的一个组件
  • scan:扫描

base-package指定Spring框架扫描的包路径，它会扫描指定包及其子包中的所有类上的注解。

  • 包路径越多[如:com.itheima.dao.impl]，扫描的范围越小速度越快
  • 包路径越少[如:com.itheima],扫描的范围越大速度越慢
  • 一般扫描到项目的组织名称即Maven的groupId下[如:com.itheima]即可。

2、在BookServiceImpl类上也添加@Component交给Spring框架管理

@Component
public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

说明:

  • BookServiceImpl类没有起名称，所以在App中是按照类型来获取bean对象

  • @Component注解如果不起名称，会有一个默认值就是当前类名首字母小写，所以也可以按照名称获取，如

    BookService bookService = (BookService)ctx.getBean("bookServiceImpl");
System.out.println(bookService);

对于@Component注解，还衍生出了其他三个注解@Controller、@Service、@Repository

知识点1:@Component等
名称@Component/@Controller/@Service/@Repository
类型类注解
位置类定义上方
作用设置该类为spring管理的bean
属性value（默认）：定义bean的id

3.2 纯注解开发模式

步骤1:创建配置类

创建一个配置类SpringConfig

public class SpringConfig {
}
步骤2:标识该类为配置类

在配置类上添加@Configuration注解，将其标识为一个配置类,替换applicationContext.xml

@Configuration
public class SpringConfig {
}
步骤3:用注解替换包扫描配置

在配置类上添加包扫描注解@ComponentScan替换<context:component-scan base-package=""/>

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}
步骤4:创建运行类并执行
public class AppForAnnotation {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

纯注解开发的方式就已经完成了，主要内容包括:

  • Java类替换Spring核心配置文件

    1660734891867

  • @Configuration注解用于设定当前类为配置类

  • @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

    @ComponentScan({com.itheima.service","com.itheima.dao"})

  • 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

    //加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
知识点1：@Configuration
名称@Configuration
类型类注解
位置类定义上方
作用设置该类为spring配置类
属性value（默认）：定义bean的id
知识点2：@ComponentScan
名称@ComponentScan
类型类注解
位置类定义上方
作用设置spring配置类扫描路径，用于加载使用注解格式定义的bean
属性value（默认）：扫描路径，此路径可以逐层向下扫描

小结:

这一节重点掌握的是使用注解完成Spring的bean管理，需要掌握的内容为:

  • 记住@Component、@Controller、@Service、@Repository这四个注解
  • applicationContext.xml中<context:component-san/>的作用是指定扫描包路径，注解为@ComponentScan
  • @Configuration标识该类为配置类，使用类替换applicationContext.xml文件
  • ClassPathXmlApplicationContext是加载XML配置文件
  • AnnotationConfigApplicationContext是加载配置类

3.3 注解开发bean作用范围与生命周期管理

3.3.2 Bean的作用范围
知识点1：@Scope
名称@Scope
类型类注解
位置类定义上方
作用设置该类创建对象的作用范围
可用于设置创建出的bean是否为单例对象
属性value（默认）：定义bean作用范围，
默认值singleton（单例），可选值prototype（非单例）
3.3.3 Bean的生命周期

注意:@PostConstruct和@PreDestroy注解如果找不到，需要导入下面的jar包

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

找不到的原因是，从JDK9以后jdk中的javax.annotation包被移除了，这两个注解刚好就在这个包中。

知识点1：@PostConstruct初始化方法
名称@PostConstruct
类型方法注解
位置方法上
作用设置该方法为初始化方法
属性无
知识点2：@PreDestroy销毁方法
名称@PreDestroy
类型方法注解
位置方法上
作用设置该方法为销毁方法
属性无

小结

1660735031091

3.4 注解开发依赖注入

3.4.2 注解实现按照类型注入
  • 自动装配基于反射设计创建对象并通过暴力反射为私有属性进行设值
  • 普通反射只能获取public修饰的内容
  • 暴力反射除了获取public修饰的内容还可以获取private修改的内容
  • 所以此处无需提供setter方法
注意：

  • @Autowired默认按照类型自动装配，如果IOC容器中同类的Bean找到多个，就按照变量名和Bean的名称匹配

  • 先按照类型匹配，再按照名称匹配，如果都匹配不上就会报错

  • @Qualifier注解后的值就是需要注入的bean的名称。

  • 引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象。

注意:@Qualifier不能独立使用，必须和@Autowired一起使用

3.4.5 注解读取properties配置文件

  • 如果读取的properties配置文件有多个，可以使用@PropertySource的属性来指定多个

    @PropertySource({"jdbc.properties","xxx.properties"})

  • @PropertySource注解属性中不支持使用通配符*,运行会报错

    @PropertySource({"*.properties"})

  • @PropertySource注解属性中可以把classpath:加上,代表从当前项目的根路径找文件

    @PropertySource({"classpath:jdbc.properties"})
知识点1：@Autowired
名称@Autowired
类型属性注解 或 方法注解（了解） 或 方法形参注解（了解）
位置属性定义上方 或 标准set方法上方 或 类set方法上方 或 方法形参前面
作用为引用类型属性设置值
属性required：true/false，定义该属性是否允许为null
知识点2：@Qualifier
名称@Qualifier
类型属性注解 或 方法注解（了解）
位置属性定义上方 或 标准set方法上方 或 类set方法上方
作用为引用类型属性指定注入的beanId
属性value（默认）：设置注入的beanId
知识点3：@Value
名称@Value
类型属性注解 或 方法注解（了解）
位置属性定义上方 或 标准set方法上方 或 类set方法上方
作用为 基本数据类型 或 字符串类型 属性设置值
属性value（默认）：要注入的属性值
知识点4：@PropertySource
名称@PropertySource
类型类注解
位置类定义上方
作用加载properties文件中的属性值
属性value（默认）：设置加载的properties文件对应的文件名或文件名组成的数组

4，IOC/DI注解开发管理第三方bean

4.2 注解开发管理第三方bean——DruidDataSource数据源
步骤1:导入对应的jar包
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>
步骤2:新建JdbcConfig文件
/**
 * 第三方Bean，数据源管理
 */
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;

    //替代原生mybatis中的连接数据信息
    @Bean
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}
步骤3:数据源的文件从jdbc.properties中读取
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db14
jdbc.username=root
jdbc.password=1234
步骤4：在Spring配置类中引入JdbcConfig数据源配置文件
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

注意:

  • 扫描注解可以移除

  • @Import参数需要的是一个数组，可以引入多个配置类。

  • @Import注解在配置类中只能写一次

知识点1：@Bean

名称@Bean
类型方法注解
位置方法定义上方
作用设置该方法的返回值作为spring管理的bean
属性value（默认）：定义bean的id

知识点2：@Import

名称@Import
类型类注解
位置类定义上方
作用导入配置类
属性value（默认）：定义导入的配置类类名，
当配置类有多个时使用数组格式一次性导入多个配置类
5，注解开发总结

1660735870462

6，Spring整合

6.1 Spring整合Mybatis思路分析
  • 1660736025543

6.2 Spring整合Mybatis

  • Spring要管理MyBatis中的SqlSessionFactory

  • Spring要管理Mapper接口的扫描

步骤1:项目中导入整合需要的jar包
<dependency>
    <!--Spring操作数据库需要该jar包-->
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<dependency>
    <!--
		Spring与Mybatis整合的jar包
		这个jar包mybatis在前面，是Mybatis提供的
	-->
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>
步骤2:创建Spring的主配置类
//配置类注解
@Configuration
//包扫描，主要扫描的是项目中的AccountServiceImpl类
@ComponentScan("com.itheima")
public class SpringConfig {
}
步骤3:创建数据源的配置类

在配置类中完成数据源的创建

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;

    //替代原生mybatis中的连接数据信息
    @Bean
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}
步骤4:主配置类中读properties并引入数据源配置类
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import(JdbcConfig.class)
public class SpringConfig {
}
步骤5:创建Mybatis配置类并配置SqlSessionFactory
public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        //设置模型类的别名扫描
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        //设置数据源
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean	    //替代原生mybatis中的包扫描
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

说明:

  • 使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息

  • 使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中

    1660736340271

    • 这个MapperScannerConfigurer对象也是MyBatis提供的专用于整合的jar包中的类，用来处理原始配置文件中的mappers相关配置，加载数据层的Mapper接口类
    • MapperScannerConfigurer有一个核心属性basePackage，就是用来设置所扫描的包路径
步骤6:主配置类中引入Mybatis配置类
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
步骤7:编写运行类

在运行类中，从IOC容器中获取Service对象，调用方法获取结果

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        AccountService accountService = ctx.getBean(AccountService.class);
        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

Spring与Mybatis的整合用到的两个类分别是:

  • SqlSessionFactoryBean
  • MapperScannerConfigurer

6.3 Spring整合Junit

步骤1:引入依赖
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
步骤2:编写测试类
//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = {SpringConfiguration.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }
    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

注意:

  • 单元测试，如果测试的是注解配置类，则使用@ContextConfiguration(classes = 配置类.class)
  • 单元测试，如果测试的是配置文件，则使用@ContextConfiguration(locations={配置文件名,...})
  • Junit运行后是基于Spring环境运行的，所以Spring提供了一个专用的类运行器，这个类运行器就在Spring的测试专用包中提供的，导入的坐标就是这个东西SpringJUnit4ClassRunner
知识点1：@RunWith
名称@RunWith
类型测试类注解
位置测试类定义上方
作用设置JUnit运行器
属性value（默认）：运行所使用的运行期
知识点2：@ContextConfiguration
名称@ContextConfiguration
类型测试类注解
位置测试类定义上方
作用设置JUnit加载的Spring核心配置
ce;
@Test
public void testFindById(){
    System.out.println(accountService.findById(1));

}
@Test
public void testFindAll(){
    System.out.println(accountService.findAll());
}

}
注意:

  • 单元测试，如果测试的是注解配置类，则使用@ContextConfiguration(classes = 配置类.class)

  • 单元测试，如果测试的是配置文件，则使用@ContextConfiguration(locations={配置文件名,...})

  • Junit运行后是基于Spring环境运行的，所以Spring提供了一个专用的类运行器，这个类运行器就在Spring的测试专用包中提供的，导入的坐标就是这个东西SpringJUnit4ClassRunner

知识点1：@RunWith
名称@RunWith
类型测试类注解
位置测试类定义上方
作用设置JUnit运行器
属性value（默认）：运行所使用的运行期
知识点2：@ContextConfiguration
名称@ContextConfiguration
类型测试类注解
位置测试类定义上方
作用设置JUnit加载的Spring核心配置
属性classes：核心配置类，可以使用数组的格式设定加载多个配置类
locations:配置文件，可以使用数组的格式设定加载多个配置文件名称
天道酬勤874
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jdbc连接数据库（JDBC读取propertites属性文件）
wilson_m的博客
11-26 1788
说明： JDBC读取properties属性文件。 （1）文件的内容是格式是"键=值"（key-value）的格式。 （2）在 properties 文件中，可以用"#"来作注释。 （3）properties文件在Java编程中用到的地方很多，操作很方便。
JDBC创建,读取properties文件
mqingo的博客
11-25 4157
在src下创建jdbc.properties文件 jdbc.properties内容如下: driverClass=com.mysql.jdbc.Driver url = jdbc:mysql://localhost/jdbc name = root password = root  改动的JDBCUtil: JDBCTest:   package com.test.exampl...
Spring配置数据源之抽取jdbc的配置文件
qq_419111582的博客
11-24 226
第一步： 引入context的命名空间和约束路径 //命名空间 xmlns:context="http://www.springframework.org/schema/context" //约束路径 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 第二部： 写properties配置文件 jdbc.driver=com.mys
jdbc通过properties文件获取连接mysql8.0以上
qq_45720234的博客
04-21 1345
在resource文件下创建db.properties文件内容为 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/jdbc?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=true username=root password=1234 创建基础类BaseDao.java引入properties文件内容 package c
从properties文件中获取数据进行数据库连接
qwertylffFrieda的博客
08-02 452
从properties文件中获取数据进行数据库连接 properties文件位置 $PATH/project_name/src/jdbc.properties 在src目录下的properties文件会在WEB-INF/classes下自动生成一个相同的properties文件。 如果在下面的代码中运行语句：System.out.println(classLoader.getResource(propertiesName).getPath()); 将会打印： ..../ProjectName/WebC
spring_day03_spring_
09-28
标题中的"spring_day03_spring_"表明了本次学习的主题是关于Spring框架的第三天课程，而描述中的"heima spring source code day 03"则提示我们将深入研究黑魔法（可能指复杂或深入的内容）——Spring框架的源码。...
spring_day02_spring_
10-01
标题“spring_day02_spring_”和描述“heima spring source code day 02”表明这是一份关于Spring框架的深入学习资料，主要聚焦在源码分析上，特别是针对第一天学习后的第二天内容。标签“spring”进一步确认了讨论...
spring_day05_spring_
10-01
2. **IoC容器**：IoC（Inversion of Control）是DI的另一种表述，Spring的IoC容器负责创建对象，管理它们的生命周期，以及处理对象间的依赖关系。 3. **AOP（面向切面编程）**：Spring支持AOP，允许开发者定义“切...
spring_day06_spring_
10-03
标题中的"spring_day06_spring_"表明这是关于Spring框架的第六天学习内容，而描述中的"heima source code day 06"暗示我们将探讨的是有关Heima（可能是一个项目或公司的名称）的源代码，这与Spring框架的集成或者在...
day42_spring.zip
06-12
"day42_spring.zip"这个压缩包很可能包含了一组与Spring框架相关的学习资源，Spring是一个广泛使用的Java企业级应用开发框架，特别适用于构建服务端应用。 Spring框架的核心特性包括依赖注入（Dependency Injection...
Spring注解开发
qq_44262458的博客
09-12 134
Spring配置数据源 数据源（连接池）的作用 数据源(连接池)是提高程序性能如出现的 事先实例化数据源，初始化部分连接资源 使用连接资源时从数据源中获取 使用完毕后将连接资源归还给数据源 常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等 数据源的开发步骤 导入数据源的坐标和数据库驱动坐标 创建数据源对象 设置数据源的基本连接数据 使用数据源获取连接资源和归还连接资源 数据源的手动创建 1.导入c3p0和druid的坐标 ①导入mysql数据库驱动..
【SQL】JDBC读取properties属性文件
欲买桂花同载酒，终不似，少年游。
07-27 5168
Java 中的 properties 文件是一种配置文件，主要用于表达配置信息，文件类型为*.properties，格式为文本文件。 文件的内容是格式是"键=值"的格式，在 properties 文件中，可以用"#"来作注释。 properties文件在Java编程中用到的地方很多，操作很方便。 例如，我们可以把数据库连接信息，如URL、账号、密码这些动态信息不写在class中，
spring基于注解的方式获取.properties文件中的数据
菜鸟的升级之路
10-20 4137
最近开始学习spring的相关知识，因为很久没有写过了，所以从现在开始，我要把我的学习中遇到的难点和容易发生的bug记录下来。 昨天晚上在看关于.properties的使用的相关内容，遇到了一些bug，一直解决不了，由于今天要交作业，所以我不得不放下手头的事情赶作业。今天下午上完课重新打开电脑在看昨天的内容，才发现还是由于粗心大意，写错了一处的配置，这个错误真行让我“心醉神迷”呀！ 行了，废话
读取properties文件连接数据库
Xiazhiyu_whu的博客
11-12 643
在properties文件中配置数据库的连接信息（数据库驱动driver、数据库url、用户名和密码），在java类中读取配置参数并连接数据库。 properties文件放在resoure目录下。 db.properties [java] view plain copy driver=com.mysql.jdbc.Driver
JDBC读取properties文件
MarconiYe的博客
04-04 909
在实际开发中，JDBC获取数据库连接时，可能需要连接多个数据库，且为了代码复用性以及简洁性，我们常用properties文件来配置数据库的信息 如下，在src中创建resources包，并创建db.properties文件 在该文件中，可以配置多个数据库的信息，这里只配了一个： #mysql/test数据库配置信息 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/test user=root password=qqzj1214
Java @Value使用@PropertySource加载.properties
yuming的专栏
05-20 540
Java 使用.properties进行配置时，一般用@PropertySource进行加载文件，使用示例如下： @PropertySource(value ={"classpath:my1.properties","file:my2.properties"},ignoreResourceNotFound = true,encoding="utf-8") @PropertySource的value，指定.properties文件，不能使用通配符，如果配置项有重复，实际使用时用value={}的后面文件
jdbc中从properties文件中读取数据库连接字符串
heguikun的专栏
01-09 697
<br />--------------------------------1-------------------------<br />package com;<br />import java.io.InputStream;<br />import java.util.Properties;<br />import com.sun.org.apache.xml.internal.security.keys.content.RetrievalMethod;<br />/*<br /> *把配置文件读到内
配置类的几种写法
最新发布
全栈测试笔记
02-09 620
需求 通过java配置类实现一个数据库连接池。 以前xml中是这样写的： <!--配置德鲁伊数据库连接池--> <bean id="ds" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${jdbc.dr...
Spring-纯注解开发
u011572366的博客
07-19 167
Spring3.0升级了纯注解开发模式,使用Java类替代配置文件,开启了Spring快速开发赛道Java类替代了Spring核心配置文件。
Spring4_day03讲义2: 使用AOP增强DAO权限校验和事务管理
今天的Spring_day03课程主要围绕着引入AOP约束展开，任务包括使用Spring的AOP对客户管理的DAO进行增强以及使用Spring完成转账的事务管理。教学导航中强调掌握Spring的声明式事务和SSH的整合，而教学方法则采用案例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值