首页 > Python基础教程 >
-
java教程之Spring (2)框架(2)
2.2.5. @Value注解
<value>
//value只能设置，标量类型=基础数据类型+包装类+String
@Value注解：注入基本数据类型以及它们的包装类和String类型数据的，支持${}注入Properties文件的键值对,等同 <proprty name=”...” value=”${Key}”>。
属性：
value：注入基本数据类型和String类型数据的
2.2.5.1. 案例代码
|
package cn.zj.spring.dao.impl;
import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Repository;
import cn.zj.spring.dao.UserDao; import cn.zj.spring.pojo.User;
@Repository public class UserDaoImpl implements UserDao {
/** * @Value(value="") * 可以从Spring容器读取 .properties 配置文件内容 * value ：配置文件的对应的key -->使用 ${key} 获取 * 程序运行中自动将 properties 对应key的获取出来设置给字段 * */
//等价 <property name="driverClassName" value="${jdbc.driverClassName}"> @Value("${jdbc.driverClassName}") private String driverClassName;
@Value("${jdbc.url}") private String url;
@Value("${jdbc.username}") private String username;
@Value("${jdbc.password}") private String password;
//@Value("${jdbc.maxActive}") @Value("100") //开发者也手动赋值 private String maxActive;
@Override public void insert(User user) { System.out.println(driverClassName); System.out.println(url); System.out.println(username); System.out.println(password); System.out.println(maxActive);
} }
|
3. 模拟注册功能(使用注解方式)
3.1. DAO层代码
|
//@Component("userDao") @Repository("userDao") public class UserDaoImpl implements UserDao { @Override public void insert(User user) { System.out.println("注册的Dao方法执行"); } } |
3.2. Service层代码
|
@Service("userService") public class UserServiceImpl implements UserService {
/*@Autowired @Qualifier("userDao")*/
@Resource(name="userDao") private UserDao dao;
@Override public void register(User user) { dao.insert(user); } //因为要用 public void setDao(UserDao dao) { this.dao = dao; } } |
3.3. 表现层代码
|
@Controller public class UserController { /*@Autowired @Qualifier("userService")*/ @Resource(name="userService") private UserService service;
public void register(User user) {
service.register(user); } } |
3.4. 测试代码
|
public class UserServletTest {
@Test public void testSpring() throws Exception { //创建用户对象:模拟接受用户参数,封装对象的过程 User user = new User(); user.setUsername("张三"); user.setPassword("admin"); UserController controller = context.getBean("userController",CustomerController.class); //执行注册操作 controller.register(user); } } |
3.5. applicationContext.xml
配置文件(只需要配置一个包扫描即可)
|
<!-- 配置包扫描 cn.zj.spring : 此包以及子包全部被扫描 --> <context:component-scan base-package="cn.zj.spring"/> |
4. 纯注解配置
4.1. 问题
我们发现，之所以我们现在离不开xml配置文件，是因为我们有一句很关键的配置：
<!-- 告知spring框架在，读取配置文件，创建容器时，扫描注解，依据注解创建对象，并存入容器中 -->
<context:component-scan base-package="cn.zj.spring"></context:component-scan>
如果他要也能用注解配置，那么我们就可以脱离xml文件了。
通过@Configuration注解和@ComponentScan注解
|
替换XML配置文件的 @Configuration注解
|
@Configuration配置类注解，在纯注解配置中，类加了该注解，就意味着该类是Spring的配置类。该类的功能就是用于替代原来的XML配置文件。
作用： 用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationConfigApplicationContext(有@Configuration注解的类.class)。
|
|
@ComponentScan注解
|
@ComponentScan注解扫描类，作用就是配置扫描Spring组件类的路径。功能等同原来配置文件的 --作用： 用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的： <context:component-scan base-package="cn.zj.spring"/>是一样的。 --属性： basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。
|
|
@PropertySource注解
|
作用： 用于加载.properties文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties配置文件中，就可以使用此注解指定properties配置文件的位置。 属性： value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:
|
|
@Bean注解
|
作用： 该注解只能写在方法上，使用此方法创建一个对象，并且放入spring容器。它就相当于我们之前在xml配置中介绍的<bean标签>
属性： name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。
|
|
@Import注解
|
作用： 用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration注解。当然，写上也没问题。 <import > 属性： value[]：用于指定其他配置类的字节码。
|
4.2. 示例代码
4.2.1. 简单入门
4.2.1.1. 说明
需求：通过一个简单的入门示例，实现创建一个配置类使用@Configuration注解和@ComponentScan注解替换xml文件。
4.2.1.2. 配置步骤
4.2.1.2.1. 第一步：创建一个Java项目
创建一个Java项目，导入必须的jar包以及编写好需要的类结构。代码目录如下：
|
|
4.2.1.2.2. 第三步：编写配置类代码
--通过该配置类的代码替换掉Spring配置文件
|
package cn.zj.spring.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource;
import com.alibaba.druid.pool.DruidDataSource;
/* * @Configuration * 说明把当前类当做成Spring框架的配置文件 * @ComponentScan * 配置注解包扫描的位置 * @PropertySource("classpath:db.properties") * 读取.peroperties 后缀的配置文件 */
@Configuration //@ComponentScan(basePackages= {"cn.zj.spring.action","cn.zj.spring.service","cn.zj.spring.dao"}) @ComponentScan("cn.zj.spring") @PropertySource("classpath:db.properties") public class SpringConfig {
/** * @Value(value="") * 可以从Spring容器读取 .properties 配置文件内容 * value ：配置文件的对应的key -->使用 ${key} 获取 * 程序运行中自动将 properties 对应key的获取出来设置给字段 * */
//等价 <property name="driverClassName" value="${jdbc.driverClassName}"> @Value("${jdbc.driverClassName}") private String driverClassName;
@Value("${jdbc.url}") private String url;
@Value("${jdbc.username}") private String username;
@Value("${jdbc.password}") private String password;
@Value("${jdbc.maxActive}") private Integer maxActive;
//<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" //init-method="init" destroy-method="close"> @Bean(name="dataSource",initMethod="init",destroyMethod="close") public DataSource getDataSource() { DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(driverClassName); dataSource.setUrl(url); dataSource.setUsername(username); dataSource.setPassword(password); dataSource.setMaxActive(maxActive); return dataSource; }
}
|
4.2.1.2.3. 第四步：编写测试代码
|
package cn.zj.spring.test;
import java.sql.Connection;
import javax.sql.DataSource;
import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import cn.zj.spring.config.SpringConfig;
public class SpringTest {
@Test public void testName() throws Exception {
// 1.读取 xml 配置文件，启动框架，创建Spring容器对象 //ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 1. 读取SpringConfig 类配置文件,启动动框架，创建Spring容器对象 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
//2. 获取 连接池对象 DataSource dataSource = context.getBean("dataSource", DataSource.class);
//2.1获取数据库连接对象 Connection conn = dataSource.getConnection();
System.out.println(conn); } }
|
--测试结果，输出组件类调用方法的输出值。配置成功
|
|
5. Spring的测试
5.1. 传统的测试
存在问题:
1,每个测试都要重新启动Spring容器，启动容器的开销大，测试效率低下。
2,不应该是测试代码管理Spring容器，应该是Spring容器在管理测试代码。
|
|
5.2. 正确使用Spring的测试
|
|
5.3. 如何使用Spring测试
5.3.1. 导入spring测试的jar包
|
|
Spring测试必须保证Eclipse的单元测试的最低版本是 4.12版本,如果使用的Eclipse版本很低,那么单元测试版本可能低于4.12,那么需要开发者手动导入单元测试的jar包
如果使用Spring方式测试,必须使用两个注解
@RunWith注解
表示先启动Spring容器，把junit运行在Spring容器中
@ContextConfiguration注解
从哪里加载资源文件,默认从src(源目录)下面加载
5.3.2. 案例代码
|
package cn.zj.spring.test;
import static org.junit.Assert.*;
import javax.annotation.Resource; import javax.swing.Spring;
import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cn.zj.spring.config.SpringConfig; import cn.zj.spring.service.CustomerService;
//表示先启动Spring容器，把junit运行在Spring容器中 @RunWith(SpringJUnit4ClassRunner.class) //表示从哪里加载资源文件,默认从src(源目录)下面加载 @ContextConfiguration("classpath:applicationContext.xml") public class CustomerServiceTest {
@Resource ApplicationContext context;
@Test public void testSpring() throws Exception { //1.获取Spring容器对象 //AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(“applicationContext.xml”);
//2.获取CustomerController对象 CustomerService controller = context.getBean("customerService",CustomerService.class);
//执行保存方法 controller.save(); } }
|
5.3.3. 纯注解方式的配置
@ContextConfiguration()
classes 属性: 读取spring的纯java配置文件
|
package cn.zj.spring.test;
import static org.junit.Assert.*;
import javax.annotation.Resource; import javax.swing.Spring;
import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cn.zj.spring.config.SpringConfig; import cn.zj.spring.service.CustomerService;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes=Spring.class) public class CustomerServiceTest {
@Resource ApplicationContext context;
@Test public void testSpring() throws Exception { //1.获取Spring容器对象 //AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
//2.获取CustomerController对象 CustomerService controller = context.getBean("customerService",CustomerService.class);
//执行保存方法 controller.save(); } } |
6. Spring的JDBC操作
Spring对象也支持JDBC,对JDBC只进行了薄薄的一层封装
问题： Java开发已经有JDBC,为什么Spring还要支持JDBC操作呢?
最重要的原因: Spring操作JDBC能自动管理事务
|
|
6.1. 操作步骤
|
1,创建数据库 spring_jdbc |
|
2.创建数据表 t_user |
|
CREATE TABLE `t_user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(20) DEFAULT NULL, `email` varchar(50) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; |
|
3.创建对应的domain对象 |
|
public class User { private Integer id; private String name; private String email; 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 String getEmail() { return email; } public void setEmail(String email) { this.email = email; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", email=" + email + "]"; } public User(Integer id, String name, String email) { super(); this.id = id; this.name = name; this.email = email; } public User() { super(); // TODO Auto-generated constructor stub }
} |
|
4.创建DAO层 |
|
public class UserDaoImpl implements UserDao {
@Override public void save(User user) {
}
@Override public void delete(Integer id) { }
@Override public void update(User user) {
}
@Override public User findById(Integer id) {
return null; }
@Override public List<User> list() {
return null; } } |
|
5.创建Service层 |
|
public class UserServiceImpl implements UserService {
private UserDao dao;
@Override public void save(User user) { dao.save(user); }
@Override public void delete(Integer id) { dao.delete(id); }
@Override public void update(User id) { dao.update(id); }
@Override public User findById(Integer id) { // TODO Auto-generated method stub return dao.findById(id); }
@Override public List<User> list() { // TODO Auto-generated method stub return dao.list(); }
public void setDao(UserDao dao) { this.dao = dao; } } |
|
6.测试代码 |
|
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class UserServiceTest {
@Resource private UserService service;
@Test public void testSave() {
User user = new User(null, "乔峰", "qf@qq.com");
service.save(user); }
@Test public void testDelete() { service.delete(3); }
@Test public void testUpdate() { User user = new User(2, "段誉", "123123sdfsdf@qq.com"); service.update(user); }
@Test public void testFindById() {
User user = service.findById(1);
System.out
|
