Spring

最新推荐文章于 2024-07-19 15:53:52 发布

远道学java

最新推荐文章于 2024-07-19 15:53:52 发布

阅读量61

点赞数

文章标签： spring java java-ee

本文链接：https://blog.csdn.net/xmcxmc___/article/details/125153770

版权

Spring概述

Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。
提供了表现层 SpringMVC和持久层 Spring JDBC Template以及 业务层 事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
两大核心：以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

Spring优势

方便解耦，简化开发
Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理
AOP编程的支持
Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。
声明式事务的支持
通过配置完成事务的管理，无需手动编程
方便测试，降低JavaEE API的使用
Spring对Junit4支持，可以使用注解测试
方便集成各种优秀框架
不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持

Spring体系结构

在这里插入图片描述

IOC

控制反转（Inverse Of Control）不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加解耦合的程序。
控制：在java中指的是对象的控制权限（创建、销毁）
反转：指的是对象控制权由原来由开发者在类中手动控制 反转到由Spring容器控制

自定义IOC容器

需求：实现service层与dao层代码解耦合
步骤分析：

创建java项目，导入自定义IOC相关坐标

<dependency> 
	<groupId>dom4j</groupId> 
	<artifactId>dom4j</artifactId> 
	<version>1.6.1</version> 
</dependency>
<dependency> 
	<groupId>jaxen</groupId> 
	<artifactId>jaxen</artifactId> 
	<version>1.1.6</version> 
</dependency>
<dependency> 
	<groupId>junit</groupId> 
	<artifactId>junit</artifactId>
	<version>4.12</version> 
</dependency>

编写Dao接口和实现类

public interface UserDao { 
	void save(); 
}

public class UserDaoImpl implements UserDao { 
	public void save() { 
		System.out.println("保存成功了..."); 
	} 
}

编写Service接口和实现类

public interface UserService { 
	void save(); 
}

public class UserServiceImpl implements UserService { 
	private UserDao userDao; 
	
	public void save(){ 
		userDao = new UserDaoImpl(); 
		userDao.save(); 
	} 
}

编写测试代码

public class UserTest { 
	@Test 
	public void testSave() throws Exception { 
		UserService userService = new UserServiceImpl(); 
		userService.save(); 
	} 
}

问题
当前service对象和dao对象耦合度太高，且每次new的都是一个新的对象，导致服务器压力过大。
解耦合的原则是编译期不依赖，而运行期依赖就行了
编写beans.xml
把所有需要创建对象的信息定义在配置文件中

<?xml version="1.0" encoding="UTF-8" ?> 
<beans> 
	<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean> 
</beans>

编写BeanFactory工具类

public class BeanFactory { 
	private static Map<String, Object> ioc = new HashMap<>(); 

	// 程序启动时，初始化对象实例 
	static { 
		try {
			// 1.读取配置文件 
			InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"); 
			// 2.解析xml 
			SAXReader saxReader = new SAXReader(); 
			Document document = saxReader.read(in); 
			// 3.编写xpath表达式 
			String xpath = "//bean"; 
			// 4.获取所有的bean标签 
			List<Element> list = document.selectNodes(xpath); 
			// 5.遍历并创建对象实例，设置到map集合中 
			for (Element element : list) { 
				String id = element.attributeValue("id"); 
				String className = element.attributeValue("class"); 
				Object object = Class.forName(className).newInstance(); 
				ioc.put(id, object); 
			} 
		} catch (Exception e) { 
			e.printStackTrace(); 
		} 
	}
	// 获取指定id的对象实例 
	public static Object getBean(String beandId) { 
		return ioc.get(beandId); 
	} 
}

修改UserServiceImpl实现类

public class UserServiceImpl implements UserService { 
	private UserDao userDao; 
	
	public void save() throws Exception {
		userDao = (UserDao) BeanFactory.getBean("userDao"); 
		userDao.save(); 
	} 
}

小结

升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。
之前需要一个userDao实例，需要开发者自己手动创建 new UserDao()
现在需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
最终目标：代码解耦合

Spring快速入门

需求：借助spring的IOC实现service层与dao层代码解耦合
步骤分析

创建java项目，导入spring开发基本坐标

<dependency> 
	<groupId>org.springframework</groupId> 
	<artifactId>spring-context</artifactId> 
	<version>5.1.5.RELEASE</version> 
</dependency> 
<dependency> 
	<groupId>junit</groupId> 
	<artifactId>junit</artifactId> 
	<version>4.12</version> 
</dependency>

编写Dao接口和实现类

public interface UserDao { 
	void save(); 
}

public class UserDaoImpl implements UserDao { 
	public void save() { 
		System.out.println("保存成功了..."); 
	} 
}

创建spring核心配置文件 applicationContext.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">
	 
</beans>

在spring配置文件中配置 UserDaoImpl

<beans ...> 
	<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean> 
</beans>

使用spring相关API获得Bean实例

public class UserTest { 
	@Test 
	public void testSave() throws Exception { 
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save(); 
	} 
}

Spring相关API

Spring的API体系异常庞大，我们现在只关注两个BeanFactory和ApplicationContext
在这里插入图片描述

BeanFactory

BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能。
特点：在第一次调用getBean()方法时，创建指定对象的实例

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

ApplicationContext

代表应用上下文对象，可以获得spring中IOC容器的Bean对象。
特点：在spring容器启动时，加载并创建所有对象的实例
常用实现类

ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件推荐使用这种。
FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");

常用方法

Object getBean(String name);
根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
T getBean(Class requiredType);
根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
T getBean(String name,Class requiredType);
根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。

Spring配置文件

Bean标签基本配置

<bean id="" class=""></bean>

用于配置对象交由Spring来创建。
基本属性： id：Bean实例在Spring容器中的唯一标识; class：Bean的全限定名
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

Bean标签范围配置

<bean id="" class="" scope=""></bean>

scope属性指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession 相当于 session

当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了
当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
Bean的生命周期：
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

Bean实例化三种方式

无参构造方法实例化
工厂静态方法实例化
工厂普通方法实例化

无参构造方法实例化

根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

public class StaticFactoryBean { 
	public static UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化

public class DynamicFactoryBean { 
	public UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="dynamicFactoryBean" factory- method="createUserDao"/>

Bean依赖注入

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

注入方式

构造方法

public class UserServiceImpl implements UserService { 
	private UserDao userDao; 
	
	public UserServiceImpl(UserDao userDao) { 
		this.userDao = userDao; 
	}
	
	@Override 
	public void save() { 
		userDao.save(); 
	} 
}

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl">
	<!--方式一：-->
	<!--<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/>-->
	<!--方式二：-->
	<constructor-arg name="userDao" ref="userDao"/>
</bean>

set方法

public class UserServiceImpl implements UserService { 
	private UserDao userDao; 

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

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

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
	<property name="userDao" ref="userDao"/> 
</bean>

P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件
中，如下：
首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

Bean依赖注入的数据类型

上面操作，都是注入Bean对象，除了对象的引用可以注入，普通数据类型和集合都可以在容器中进行注入。

普通数据类型
引用数据类型
集合数据类型

注入普通数据类型

public class User { 
	private String username; 
	private String age; 

	public void setUsername(String username) { 
		this.username = username; 
	}

	public void setAge(String age) { 
		this.age = age; 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>

注入集合数据类型

List集合注入

public class UserDaoImpl implements UserDao { 
	private List<Object> list; 
	public void save() { 
		System.out.println(list); 
		System.out.println("保存成功了..."); 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>
<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"> 
	<property name="list"> 
		<list>
			<value>aaa</value> 
			<ref bean="user"></ref> 
		</list> 
	</property> 
</bean>

Set集合注入

public class UserDaoImpl implements UserDao { 
	private Set<Object> set;
	public void save() { 
		System.out.println(set); 
		System.out.println("保存成功了..."); 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>
<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"> 
	<property name="set"> 
		<set>
			<value>aaa</value> 
			<ref bean="user"></ref> 
		</set> 
	</property> 
</bean>

Array数组注入

public class UserDaoImpl implements UserDao { 
	private Object[] array; 

	public void setArray(Object[] array) { 
		this.array = array; 
	}

	public void save() { 
		System.out.println(Arrays.toString(array)); 
		System.out.println("保存成功了..."); 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>
<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"> 
	<property name="array"> 
		<array> 
			<value>ccc</value> 
			<ref bean="user"></ref> 
		</array> 
	</property> 
</bean>

Map集合注入

public class UserDaoImpl implements UserDao { 
	private Map<String, Object> map; 

	public void setMap(Map<String, Object> map) { 
		this.map = map; 
	}

	public void save() { 
		System.out.println(map); 
		System.out.println("保存成功了..."); 
	} 
}

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"> 
	<property name="map"> 
		<map>
			<entry key="k1" value="ddd"></entry>
			<entry key="k2" value-ref="user"></entry> 
		</map> 
	</property> 
</bean>

Properties配置注入

public class UserDaoImpl implements UserDao { 
	private Properties properties; 

	public void setProperties(Properties properties) { 
		this.properties = properties; 
	}

	public void save() { 
		System.out.println(properties); 
		System.out.println("保存成功了..."); 
	} 
}

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"> 
	<property name="properties"> 
		<props> 
			<prop key="k1">v1</prop> 
			<prop key="k2">v2</prop> 
			<prop key="k3">v3</prop> 
		</props> 
	</property> 
</bean>

配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

1）并列的多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

2）主从配置文件

<import resource="classpath:applicationContext-xxx.xml"/>

注意：

同一个xml中不能出现相同名称的bean,如果出现会报错
多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

DbUtils（IOC实战）

编写User实体类

public class User {
    private int id;
    private String name;
    private double money;
}

编写UserDao接口和实现类

public interface UserDao {
    /**
     * 查询所有用户
     *
     * @return list
     */
    List<User> findAll();

    /**
     * 根据id查询用户
     *
     * @param id id
     * @return user
     */
    User findById(int id);

    /**
     * 保存用户
     *
     * @param user user
     */
    void saveUser(User user);

    /**
     * 更新用户
     *
     * @param user user
     */
    void updateUser(User user);

    /**
     * 根据用户id删除用户
     *
     * @param id id
     */
    void deleteUser(int id);
}

public class UserDaoImpl implements UserDao {
    private QueryRunner queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }


    public List<User> findAll() {
        String sql = "select * from account";
        try {
            return queryRunner.query(sql, new BeanListHandler<User>(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    public User findById(int id) {
        String sql = "select * from account where id = ?";
        try {
            return queryRunner.query(sql, new BeanHandler<User>(User.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void saveUser(User user) {
        String sql = "Insert into account(name, money) values(?, ?)";
        Object[] params = {user.getName(), user.getMoney()};
        try {
            queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void updateUser(User user) {
        String sql = "update account set name = ?, money = ? where id = ?";
        Object[] params = {user.getName(), user.getMoney(), user.getId()};
        try {
            queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void deleteUser(int id) {
        String sql = "delete from account where id = ?";
        try {
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

编写UserService接口和实现类

public interface UserService {
    /**
     * 查询所有用户
     *
     * @return list
     */
    List<User> findAll();

    /**
     * 根据id查询用户
     *
     * @param id id
     * @return user
     */
    User findById(int id);

    /**
     * 保存用户
     *
     * @param user user
     */
    void saveUser(User user);

    /**
     * 更新用户
     *
     * @param user user
     */
    void updateUser(User user);

    /**
     * 根据用户id删除用户
     *
     * @param id id
     */
    void deleteUser(int id);
}

public class UserServiceImpl implements UserService {
    private UserDao userDao;

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

    public List<User> findAll() {
        return userDao.findAll();
    }

    public User findById(int id) {
        return userDao.findById(id);
    }

    public void saveUser(User user) {
        userDao.saveUser(user);
    }

    public void updateUser(User user) {
        userDao.updateUser(user);
    }

    public void deleteUser(int id) {
        userDao.deleteUser(id);
    }
}

编写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"
       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">

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" 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>
    
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
        <property name="queryRunner" ref="queryRunner"></property>
    </bean>

    <bean id="userService" class="com.lagou.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

编写测试代码

public class SpringTest {
    private ClassPathXmlApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");

    private UserService userService = applicationContext.getBean(
        "userService", UserService.class);

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

    @Test
    public void testFindById() {
        System.out.println(userService.findById(1));
    }

    @Test
    public void testSaveUser() {
        User user = new User();
        user.setName("lucy");
        user.setMoney(5000.00);
        userService.saveUser(user);
    }

    @Test
    public void testUpdateUser() {
        User user = new User();
        user.setId(3);
        user.setName("jack");
        user.setMoney(5000.00);
        userService.updateUser(user);
    }

    @Test
    public void testDeleteUser() {
        userService.deleteUser(3);
    }
}

Spring注解开发

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
常用注解

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用,根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法
@Configuration	用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载 properties 文件中的配置
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包
@Import	用于导入其他配置类
@ContextConfiguration	加载spring核心配置

说明：
JDK11以后完全移除了javax扩展导致不能使用@resource注解
依赖：

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

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

<!--注解的组件扫描--> 
<context:component-scan base-package="com.lagou"></context:component-scan>

纯注解开发

DataSource 配置

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean("dataSource")
    public DataSource getDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

spring 核心配置

@Configuration
@ComponentScan("com.lagou")
@Import(DataSourceConfig.class)
public class SpringConfig {
    @Bean("queryRunner")
    public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
        return new QueryRunner(dataSource);
    }
}

持久层实现类

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Autowired
    private QueryRunner queryRunner;

    public List<User> findAll() {
        String sql = "select * from account";
        try {
            return queryRunner.query(sql, new BeanListHandler<User>(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    public User findById(int id) {
        String sql = "select * from account where id = ?";
        try {
            return queryRunner.query(sql, new BeanHandler<User>(User.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void saveUser(User user) {
        String sql = "Insert into account(name, money) values(?, ?)";
        Object[] params = {user.getName(), user.getMoney()};
        try {
            queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void updateUser(User user) {
        String sql = "update account set name = ?, money = ? where id = ?";
        Object[] params = {user.getName(), user.getMoney(), user.getId()};
        try {
            queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void deleteUser(int id) {
        String sql = "delete from account where id = ?";
        try {
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

业务层实现类

@Service("userService")
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    public List<User> findAll() {
        return userDao.findAll();
    }

    public User findById(int id) {
        return userDao.findById(id);
    }

    public void saveUser(User user) {
        userDao.saveUser(user);
    }

    public void updateUser(User user) {
        userDao.updateUser(user);
    }

    public void deleteUser(int id) {
        userDao.deleteUser(id);
    }
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class SpringTest {
    /*private ClassPathXmlApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");

    private UserService userService = applicationContext.getBean(
        "userService", UserService.class);*/

    @Autowired
    private UserService userService;

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

    @Test
    public void testFindById() {
        System.out.println(userService.findById(1));
    }

    @Test
    public void testSaveUser() {
        User user = new User();
        user.setName("lucy");
        user.setMoney(5000.00);
        userService.saveUser(user);
    }

    @Test
    public void testUpdateUser() {
        User user = new User();
        user.setId(3);
        user.setName("jack");
        user.setMoney(5000.00);
        userService.updateUser(user);
    }

    @Test
    public void testDeleteUser() {
        userService.deleteUser(3);
    }
}

远道学java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring

需求：实现service层与dao层代码解耦合步骤分析：编写Dao接口和实现类编写Service接口和实现类编写测试代码问题当前service对象和dao对象耦合度太高，且每次new的都是一个新的对象，导致服务器压力过大。解耦合的原则是编译期不依赖，而运行期依赖就行了编写beans.xml把所有需要创建对象的信息定义在配置文件中编写BeanFactory工具类修改UserServiceImpl实现类小结升级后的BeanFactory就是
复制链接

扫一扫