使用注解实现Spring开发入门
IOC/DI的注解开发
Spring的注解开发可以简化开发。Spring2.0版本开始支持注解,2.5版本注解功能趋于完善。3.0版本支持纯注解开发。
纯注解开发模式
Spring3.0开启了纯注解开发模式,使用Java类代替配置文件,开启了Spring快速开发赛道。
实现思路
将配置文件applicationContext.xml删除掉,使用类来替换。
实现步骤
- 删除原XML配置
- 实现类上添加注解(@Component以及@Autowired)
@Service("bookService")
public class BookServiceImpl implements BookService {
@Autowired
public BookDao bookDao;
@Value("你好呀")
public String name;
@Override
public void save() {
System.out.println("调用BookServiceImpl的save方法");
}
}
- 创建配置类并标识为配置类以及添加包扫描注释
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}
- 创建运行类并执行
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
BookService bookService = (BookService)ctx.getBean("bookService");
bookDao.save();
bookService.save();
System.out.println(bookService.name);
}
}
学习总结
使用纯注解进行IOC/DI开发的关键步骤如下
-
为创建好的Impl类添加注解,@Component(“id”)、@Value(“xxx”)、@AutoWired
-
创建配置类,需要向配置类添加注解@Configuration以及@ComponentScan(“com.itheima”)
-
创建运行类并执行
@Component(“id”):将类申明为ioc容器中的bean
@Value(“xxx”):实现DI,为类中的简单属性赋值,比如String,int…
@AutoWired:实现DI,为类中的像是名为userDao属性创建对象
@Configuration:申明该类为Spring配置类
@ComponentScan(“”):扫描指定目录下的bean
@Service@Repository@Controller为@Component的衍生,他们的功能是一样的,这样做的目的是能更好的区分。
除此之外,还有一些注解非常有用,像是用于生命周期管理以及作用范围:
@Scope(“prototype”):是否为单例模式
@PostConstruct:申明在初始化时的方法上
@PreDestroy:申明在销毁前的方法上
需要注意的是:
1.使用配置文件获得applicationContext时,采用的是new ClassPathXmlApplicationContext("applicationContext.xml")
而在使用注解时,采用的是new AnnotationConfigApplicationContext(SpringConfig.class)
2.@AutoWired默认按照类型自动匹配,如果IOC容器中同类的Bean找到多个,就按照变量名和Bean的名称匹配。
IOC/DI注解管理第三方bean
由于第三方的类都在jar包中,无法直接在类上添加注解。
此时,我们用到了一个全新的注解@Bean
**注意!!可以通过在方法的形参来解决第三方bean需要依赖IOC容器中bean的问题。**当同种类的形参不止一个时,形参名需要指定被依赖bean的名称。
注解开发管理第三方bean
- 在Spring配置类上添加@PropertySource(jdbc.properties")
@Configuration
@ComponentScan("com.itheima")
@PropertySource("jdbc.properties")
public class SpringConfig {
}
- 创建JdbcConfig配置类,使用@Bean修饰获取DataSource的方法
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;
@Bean("druidDataSource")
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(username);
ds.setPassword(password);
return ds;
}
}
- 在Spring配置类上使用@Import引入JdbcConfig配置类
@Import(JdbcConfig.class)
@Configuration
@ComponentScan("com.itheima")
@PropertySource("jdbc.properties")
public class SpringConfig {
}
- 创建运行类并执行
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
DataSource dataSource = (DataSource) ctx.getBean("druidDataSource");
System.out.println(dataSource);
}
}
学习总结
使用注解管理第三方bean与配置文件管理第三方bean很不一样。
使用配置文件管理第三方bean非常简单,只需要设置好配置文件中bean的class以及properties即可。比如<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="${jdbc.url}"/>
使用注解管理bean,只需要在实现类的上方使用注解@Component即可。但是第三方Bean通常都是Jar包,没法直接在类的上方加@Component。
此时需要使用@Bean来修饰获取实现类对象的方法。通常这种方法写在配置类中,像是JdbcConfig.java。然后Spring的配置类使用@Import导入JdbcConfig配置类。
Spring与Mybatis以及Junit的整合开发
Spring整合Mybatis
Spring需要完成的任务
- Spring要管理MyBatis中的SqlSessionFactory
- Spring要管理Mapper接口的扫描
Mybatis开发的步骤如下:
- 准备数据库表
create database spring_db character set utf8;
use spring_db;
create table tbl_account(
id int primary key auto_increment,
name varchar(35),
money double
);
insert into tbl_account(name,money)
values('fyc',200),
('ghh',1000);
- 创建项目导入jar包
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
- 在resource下添加名为
mybatis-config.xml
的Mybatis核心配置文件
<?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>
<properties resource="jdbc.properties"></properties>
<typeAliases>
<package name="com.itheima.domain"/>
</typeAliases>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
<mappers>
<package name="com.itheima.dao"></package>
</mappers>
</configuration>
- 根据表创建模型
package com.itheima.domain;
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
- 创建Dao接口
package com.itheima.dao;
import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
public interface AccountDao {
@Insert("insert into tbl_account(name,money)values(#{name},#{money})")
void save(Account account);
@Delete("delete from tbl_account where id = #{id} ")
void delete(Integer id);
@Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
void update(Account account);
@Select("select * from tbl_account")
List<Account> findAll();
@Select("select * from tbl_account where id = #{id} ")
Account findById(Integer id);
}
- 添加jdbc.properties文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
- 编写应用程序
package com.itheima;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class App {
public static void main(String[] args) throws IOException {
// 1. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 2. 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
// 4. 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 5. 执行SqlSession对象执行查询,获取结果User
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
Account ac = accountDao.findById(2);
System.out.println(ac);
// 6. 释放资源
sqlSession.close();
}
}
学习总结:
MyBatis开发过程如下:
第一步,需要创建数据库并添加数据。
第二步,需要在pom.xml导入mybatis,jdbc等相关的jar包。
第三步,创建并配置MyBatis的核心配置文件,主要包括连接数据库的四要素,typeAliases以及mapper和resultMap 。
第四步,创建Dao接口,在接口中使用注解的方式完成sql语句编写。
第五步,编写运行类,读取MyBatis配置类,创建SqlSessionFactory,创建SqlSession,调用SqlSession的getMapper方法,得到Dao层中接口的对象。然后调用该对象的方法完成增删改查操作。最后记得关闭SqlSession对象。
以上便是MyBatis的开发过程,这里只是简单的概括了一些。使用Spring整合MyBatis需要解决两个问题,第一个是获取SqlSessionFactory并设置typeAliases。第二个是管理Mapper接口的扫描。
接下来我们开始使用Spring整合MyBatis
Spring整合Mybatis的步骤如下
- 在项目中导入整合需要的jar包(在mybatis项目的基础上)
<!--Spring操作数据库需要该Jar包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!--Mybatis提供的整合Spring的Jar包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
- 创建Spring的主配置类
package com.itheima.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ComponentScan("com.itheima")
//@PropertySource:加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
- 创建数据源的配置
package com.itheima.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
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;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}
- 主配置类中读properties并引入数据源配置类
@PropertySource("classpath:jdbc.properties")
- 创建MyBatis配置类并创建两个方法分别获取SqlSessionFactoryBean以及MapperScannerConfigurer对象
package com.itheima.config;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
//定义bean,SqlSessionFactoryBean,用于产生SqlSessionFactory对象
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
//为SqlSessionFactoryBean对象设置别名
ssfb.setTypeAliasesPackage("com.itheima.domain");
//为SqlSessionFactoryBean对象设置数据源
ssfb.setDataSource(dataSource);
return ssfb;
}
//定义bean,返回MapperScannerConfigurer对象
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
//通过包扫描的方式,为MyBatis设置Mapper映射
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
- 主配置类中引入MyBatis配置类
@Import({JdbcConfig.class,MybatisConfig.class})
- 创建Service层,编写Service层接口和实现类
package com.itheima.service;
import com.itheima.domain.Account;
import java.util.List;
public interface AccountService {
void save(Account account);
void delete(Integer id);
void update(Account account);
List<Account> findAll();
Account findById(Integer id);
}
package com.itheima.service.impl;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
public void save(Account account) {
accountDao.save(account);
}
public void update(Account account){
accountDao.update(account);
}
public void delete(Integer id) {
accountDao.delete(id);
}
public Account findById(Integer id) {
return accountDao.findById(id);
}
public List<Account> findAll() {
return accountDao.findAll();
}
}
- 编写运行类
package com.itheima;
import com.itheima.config.SpringConfig;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App2 {
public static void main(String[] args) {
//1.通过纯注解开发的方式获取applicationContext对象
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
//2.调用ctx的getBean方法得到ioc容器中AccountService对象
AccountService accountService = ctx.getBean(AccountService.class);
//3.调用AccountService对象的方法
Account ac = accountService.findById(2);
System.out.println(ac);
}
}
运行代码后,可以发现代码正常运行,控制台打印预期的结果。
学习总结
Spring整合MyBatis的步骤如下(在MyBatis项目的基础上):
第一步,导入spring操作jdbc以及mybatis提供整合spring的jar包
第二步,创建mybatis的配置类,需要创建两个方法分别返回SqlSessionFactoryBean和MapperScannerConfigurer。其中,SqlSessionFactoryBean需要设置typeAliases以及dataSource,MapperScannerConfigurer需要设置BasePackage。
第三步,在Spring的配置文件中配置MyBatisConfig注解。
第四步,创建Service层,编写接口和实现方法。service层接口方法和Dao层一样,实现类需要添加@Service注解,类中还需要使用@AutoWired引入Dao层接口,重写的方法直接调用Dao层申明的方法。
第五步,创建运行类,在运行类创建ctx对象,再调用ctx对象的getBean方法获取service对象,调用其方法。至此,便完成了Spring整合MyBatis的全部操作。
Spring整合Junit
整合Junit与整合Druid和MyBatis差异比较大,因为他不是程序的主体,不会参与程序的运行。它只是一个辅助工具。
Spring整合Junit的步骤如下:
- 引入依赖
<!--Junit测试类jar包-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--Spring测试相关的jar包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
- 编写测试类
import com.itheima.config.SpringConfig;
import com.itheima.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = {SpringConfig.class})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
System.out.println(accountService.findById(1));
}
@Test
public void testFindAll(){
System.out.println(accountService.findAll());
}
}
学习总结
Spring整合Junit的步骤只需要两步,首先在pom.xml中导入依赖,分别是junit和spring-test的jar包。然后在test/java目录下创建测试类,测试类上需要有@RunWith以及@ContextConfiguration的注释。类中的引用类型属性可以直接使用@AutoWired方式创建对象。
关于对Spring整合MyBatis以及Junit的理解。
之前通过学习Spring的IOC以及DI,可以不需要使用new即可创建对象,这样做的好处是不需要用new的方式,而是使用配置文件或者注解的方式完成对象创建,可以减少代码耦合,将所有的对象全都放在IOC容器中,使用DI的方式管理对象与对象之间的依赖。
对Spring整合MyBatis的理解:通过编写MyBatis的代码我们发现SqlSessionFactory是MyBatis的核心,Spring整合MyBatis之后就不需要new SqlSessionFactoryBuilder()
,所有的对象都已经存放在ioc容器中,用的时候只需要调用applicationContext的getBean()方法获取相关的service对象即可完成对数据库的CRUD操作。
MyBatis操作数据库,并把相应的操作写在Dao层。Spring整合MyBatis,通过创建Service层接口(申明方法)和实现类(调用DAO层方法)并添加@Service注解封装成Bean。通过在运行时类中调用getBean(XXXService.class)的方式得到对象并调用其方法。
对Spring整合Junit的理解:因为有些时候需要测试像是Bean对象中的一些方法。如果Spring没有整合Junit的话,需要先使用new AnnotationConfigApplicationContext(SpringConfig.class)的方式得到ctx对象,再通过getBean(Xxx.class)的方式得到对象,才能调用对象的方法。很明显,这样太麻烦了。
Spring整合Junit后将会简化这些过程。而且整合起来也非常简单。
第一步是在pom.xml中添加junit以及spring-test依赖。
第二步在测试类上添加@RunWith(SpringJUnit4ClassRunner.class)
设置类运行器以及@ContextConfiguration(classes = {SpringConfig.class})
设置Spring环境对应的配置类。
第三步在类中将需要测试的对象申明为属性并添加@AutoWired注解。之后就可以在@Test方法中调用这些属性来测试了。