基于SSM框架和easyUI框架的简易人事管理系统（四）

基于SSM框架和easyUI框架的简易人事管理系统（四）

现在编写需要用到的方法和实现类

也许有人会问为什么要service层分接口和实现类，其实需要这么做的例子很多，并且这么做会很方便，下边简单总结下为什么分接口层和实现类，有不一样的见解可以提出来呀。
1可以在尚未实现具体Service情况下编写上层改代码,如Controller对Service的调用
2Spring无论是AOP还是事务管理的实现都是基于动态代理的,而动态代理的实现依赖于接口,所以必须有接口的定义才能使用这些功能
3可以对Service进行多实现

service的编写

AdminService

记住如果是注解开发一定要在实现类上添加注解@Service
接口

package service;

import domain.Admin;

import java.util.List;
import java.util.Map;

public interface AdminService {

    /** 登录
     *
     * @param admin
     * @return
     */
    public Admin login(Admin admin);

    /** 根据条件查询管理员
     *
     * @param map
     * @return
     */
    public List<Admin> findAdmins(Map<String, Object> map);

    /** 根据条件查询管理员人数
     *
     * @param map
     * @return
     */
    public Integer getCount(Map<String, Object> map);

    /** 添加管理员
     *
     * @param admin
     * @return
     */
    public Integer addAdmin(Admin admin);

    /** 修改管理员
     *
     * @param admin
     * @return
     */
    public Integer updateAdmin(Admin admin);

    /** 删除管理员
     *
     * @param id
     * @return
     */
    public Integer deleteAdmin(Integer id);
}

impl

package service.impl;

import dao.AdminDao;
import domain.Admin;
import org.springframework.stereotype.Service;
import service.AdminService;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service("adminService")
public class AdminServiceImpl implements AdminService {

    // 自动注入 DAO 对象
    @Resource
    private AdminDao adminDao;

    // 实现接口中的方法

    @Override
    public Admin login(Admin admin) {

        return adminDao.login(admin);
    }

    @Override
    public List<Admin> findAdmins(Map<String, Object> map) {

        return adminDao.findAdmins(map);
    }

    @Override
    public Integer getCount(Map<String, Object> map) {

        return adminDao.getCount(map);
    }

    @Override
    public Integer addAdmin(Admin admin) {

        return adminDao.addAdmin(admin);
    }

    @Override
    public Integer updateAdmin(Admin admin) {

        return adminDao.updateAdmin(admin);
    }

    @Override
    public Integer deleteAdmin(Integer id) {

        return adminDao.deleteAdmin(id);
    }

}

DepartmentService

接口

package service;

import domain.Department;

import java.util.List;
import java.util.Map;

public interface DepartmentService {

    /** 根据条件查询部门
     *
     * @param map
     * @return
     */
    public List<Department> findDepartments(Map<String, Object> map);

    /** 根据条件查询部门数量
     *
     * @param map
     * @return
     */
    public Integer getCount(Map<String, Object> map);

    /** 添加部门
     *
     * @param department
     * @return
     */
    public Integer addDepartment(Department department);

    /** 修改部门
     *
     * @param department
     * @return
     */
    public Integer updateDepartment(Department department);

    /** 删除部门
     *
     * @param id
     * @return
     */
    public Integer deleteDepartment(Integer id);
}

impl

package service.impl;

import dao.DepartmentDao;
import domain.Department;
import org.springframework.stereotype.Service;
import service.DepartmentService;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service("departmentService")
public class DepartmentServiceImpl implements DepartmentService {

    // 自动注入 DAO 对象
    @Resource
    private DepartmentDao departmentDao;

    // 实现接口中的方法

    @Override
    public List<Department> findDepartments(Map<String, Object> map) {

        return departmentDao.findDepartments(map);
    }

    @Override
    public Integer getCount(Map<String, Object> map) {

        return departmentDao.getCount(map);
    }

    @Override
    public Integer addDepartment(Department department) {

        return departmentDao.addDepartment(department);
    }

    @Override
    public Integer updateDepartment(Department department) {

        return departmentDao.updateDepartment(department);
    }

    @Override
    public Integer deleteDepartment(Integer id) {
        Integer flag = null;
        // 如果删除关联外键的行记录，抛出异常
        try {
            flag =  departmentDao.deleteDepartment(id);
        } catch (Exception e) {
            throw new RuntimeException();
        }

        return flag;
    }
}

EmployeeService

接口

package service;


import domain.Employee;
import domain.Post;

import java.util.List;
import java.util.Map;

public interface EmployeeService {

    /** 根据条件查询员工
     *
     * @param map
     * @return
     */
    public List<Post>findEmployees(Map<String, Object> map);

    /** 根据条件查询员工人数
     *
     * @param map
     * @return
     */
    public Integer getCount(Map<String, Object> map);

    /** 添加员工
     *
     * @param employee
     * @return
     */
    public Integer addEmployee(Employee employee);

    /** 修改员工
     *
     * @param employee
     * @return
     */
    public Integer updateEmployee(Employee employee);

    /** 删除员工
     *
     * @param id
     * @return
     */
    public Integer deleteEmployee(String id);
}

impl

package service.impl;

import dao.EmployeeDao;
import domain.Employee;
import domain.Post;
import org.springframework.stereotype.Service;
import service.EmployeeService;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {

    // 自动注入 DAO 对象
    @Resource
    private EmployeeDao employeeDao;

    // 实现接口中的方法

    @Override
    public List<Post> findEmployees(Map<String, Object> map) {

        return employeeDao.findEmployees(map);
    }

    @Override
    public Integer getCount(Map<String, Object> map) {

        return employeeDao.getCount(map);
    }

    @Override
    public Integer addEmployee(Employee employee) {
        Integer flag = null;
        // 如果插入记录主键重复，抛出异常
        try {
            flag =  employeeDao.addEmployee(employee);
        } catch (Exception e) {
            throw new RuntimeException();
        }

        return flag;
    }

    @Override
    public Integer updateEmployee(Employee employee) {

        return employeeDao.updateEmployee(employee);
    }

    @Override
    public Integer deleteEmployee(String id) {

        return employeeDao.deleteEmployee(id);
    }

}

PositionService

接口

package service;

import domain.Position;

import java.util.List;
import java.util.Map;

public interface PositionService {

    /** 根据条件查询职位
     *
     * @param map
     * @return
     */
    public List<Position> findPositions(Map<String, Object> map);

    /** 根据条件查询职位数量
     *
     * @param map
     * @return
     */
    public Integer getCount(Map<String, Object> map);

    /** 添加职位
     *
     * @param position
     * @return
     */
    public Integer addPosition(Position position);

    /* 修改职位
     *
     * @param position
     * @return
     */
    public Integer updatePosition(Position position);

    /** 删除职位
     *
     * @param id
     * @return
     */
    public Integer deletePosition(Integer id);
}

impl

package service.impl;

import dao.PositionDao;
import domain.Position;
import org.springframework.stereotype.Service;
import service.PositionService;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service("positionService")
public class PositionServiceImpl implements PositionService {

    // 自动注入 DAO 对象
    @Resource
    private PositionDao positionDao;

    // 实现接口中的方法

    @Override
    public List<Position> findPositions(Map<String, Object> map) {

        return positionDao.findPositions(map);
    }

    @Override
    public Integer getCount(Map<String, Object> map) {

        return positionDao.getCount(map);
    }

    @Override
    public Integer addPosition(Position position) {

        return positionDao.addPosition(position);
    }

    @Override
    public Integer updatePosition(Position position) {

        return positionDao.updatePosition(position);
    }

    @Override
    public Integer deletePosition(Integer id) {
        Integer flag = null;
        // 如果删除关联外键的行记录，抛出异常
        try {
            flag = positionDao.deletePosition(id);
        } catch (Exception e) {
            throw new RuntimeException();
        }

        return flag;
    }

}

PostService

接口

package service;

import domain.Post;

import java.util.List;
import java.util.Map;

public interface PostService {

    /** 根据条件查询公告
     *
     * @param map
     * @return
     */
    public List<Post>findPosts(Map<String, Object> map);

    /** 根据条件查询公告数量
     *
     * @param map
     * @return
     */
    public Integer getCount(Map<String, Object> map);

    /** 添加公告
     *
     * @param post
     * @return
     */
    public Integer addPost(Post post);

    /** 修改公告
     *
     * @param post
     * @return
     */
    public Integer updatePost(Post post);

    /** 删除公告
     *
     * @param id
     * @return
     */
    public Integer deletePost(Integer id);

    /** 根据 ID 查询公告信息
     *
     * @param id
     * @return
     */
    public Post getPostById(Integer id);
}

impl

package service.impl;

import dao.PostDao;
import domain.Post;
import org.springframework.stereotype.Service;
import service.PostService;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service("postService")
public class PostServiceImpl implements PostService {

    // 自动注入 DAO 对象
    @Resource
    private PostDao postDao;

    // 实现接口中的方法

    @Override
    public List<Post> findPosts(Map<String, Object> map) {

        return postDao.findPosts(map);
    }

    @Override
    public Integer getCount(Map<String, Object> map) {

        return postDao.getCount(map);
    }

    @Override
    public Integer addPost(Post post) {

        return postDao.addPost(post);
    }

    @Override
    public Integer updatePost(Post post) {

        return postDao.updatePost(post);
    }

    @Override
    public Integer deletePost(Integer id) {

        return postDao.deletePost(id);
    }

    @Override
    public Post getPostById(Integer id) {

        return postDao.getPostById(id);
    }

}

service层算是写完了，然后编写spring的配置文件，并且和mybatis结合起来

spring-mybati.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" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-4.2.xsd
          http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">

    <!-- 自动扫描有 Spring 相关注解的类，并把这些类注册为 bean -->
    <context:component-scan base-package="service" />

    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置数据源 -->
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <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>
    <!-- MyBatis 的 SqlSession 的工厂，并引用数据源，扫描 MyBatis 的配置文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:/mappers/*.xml"/>
        <property name="configLocation" value="classpath:mybatis-config.xml" />
    </bean>
    <!-- MyBatis 自动扫描加载 Sql 映射文件/接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
          p:basePackage="dao" p:sqlSessionFactoryBeanName="sqlSessionFactory">

    </bean>
    <!-- JDBC 事务管理器 -->
    <bean id="txManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 启用支持 annotation 注解方式事务管理 -->
    <tx:annotation-driven transaction-manager="txManager" />

</beans>