第一次尝试着用Java做Web开发，使用了Java Spring框架，顺便说一句，如果使用Spring开发，建议使用STS(Spring Tool Suite) IDE，它很好的集成了Spring、Maven等框架，使用起来特别方便，尤其是第一次使用Spring框架进行开发，它极大的方便了开发人员，通过快捷菜单及可很简单的配置好Spring开发环境，自动下载、更新Maven依赖包。话不多讲，回到文章的正题。
Spring是一个在Java业界很流行的MVC框架，所谓MVC即模型－视图－控制器，将应用程序的逻辑层与展现层进行分离的一种设计模式。
- 模型（Model）代表数据控制器。数据的读取，插入，更新都是由模型来负责。
- 视图（View）是展示给用户的最终页面。视图负责将数据以用户友好的形式展现出来。
- 控制器（Controller）是模型，视图以及其他任何处理HTTP请求所必须的资源之前的中介
概述
一个典型的页面浏览行为在程序端的流程是这样的：
- 控制器最先被调用，并被赋予外部输入
- 控制器根据外部输入向模型请求数据
- 模型从数据库获取数据并发送数据到控制器
- 控制器处理该数据并发送封装好的数据到视图
- 视图根据接到的数据最终展示页面给用户浏览
使用Java进行MVC模式开发时，往往将数据模型分为两部分，即DAO(Data Access Object，数据访问对象)和Service(业务逻辑模型)。在第2步中，控制器向模型请求数据时，并不是直接向DAO请求数据，而是通过Service向DAO请求数据。这样做的好处是，可以将业务逻辑与数据库访问独立开，为将来系统更换数据保存介质（如目前系统使用文件系统存储数据，将来可以更换为使用数据库存储，又或者是现在使用了MSSQL存储数据，将来更换为Oracle或是Mysql等）提供了很大的灵活性。
下图给出了分层设计模型。控制器只需要调用Service接口中的方法获取或是处理数据，Service层对控制器传入的数据进行业务逻辑处理封装后，传给DAO层，由DAO层负责将处理后的数据写入数据库中。
在Service层使用了抽象工厂模式来实现Service层与DAO层的低耦合，Service层并不知道DAO层是如何实现的，实际上也不需要知道系统使用了哪种数据库或是文件系统。
在DAO层使用工厂模式来创建数据模型的实体对象。
Service层设计
接口代码，这里使用了泛型技巧，确保每个Service只处理一种数据类型。
package com.emerson.etao.service;
import java.sql.SQLException;
import java.util.List;
/**
* 业务实现层接口
*
* @author Chris Mao(Zibing)
*
* @param <T>
*/
public interface IBaseService<T> {
/**
* 将实体类对象持久化，写入到数据表中
*
* @param T
* @return 返回新写入记录的自增ID
* @throws SQLException
*/
public long insert(T entity);
/**
* 根据Id值，将实体类数据回写到数据库
*
* @param id
* @param T
* @return 返回更新的记录笔数
* @throws SQLException
*/
public int update(long id, T entity);
/**
* 根据Id值从数据库中删除实体类数据
*
* @param id
* @return 返回删除的记录笔数
* @throws SQLException
*/
public int delete(long id);
/**
* 根据Id查询具体的实体类信息，并返回实体类对象
* 若查询不到数据则返回null
*
* @param id
* @return T
*/
public T getById(long id);
/**
* 获取列表
*
* @return List
* @throws SQLException
*/
public List<T> getAll();
}
下面是具体的Service层接口代码，
package com.emerson.etao.service.base;
import java.util.List;
import com.emerson.etao.entity.base.BusinessApp;
import com.emerson.etao.entity.base.Communicator;
import com.emerson.etao.entity.base.Customer;
import com.emerson.etao.service.IBaseService;
/**
* 客服类操作接口
*
* @author Chris Mao(Zibing)
* @param <T>
*
* @param <T>
*/
public interface ICommunicatorService extends IBaseService<Communicator> {
public List<Communicator> getAll(Customer customer);
/**
* 为客服分配商业应用
*
* @param c
* @param appList
* @see BusinessApp
*/
public void assignBusinessApp(Communicator communicator, List<BusinessApp> appList, boolean deleteExists);
/**
* 为客服分配客户
*
* @param c
* @param customerList
* @see Customer
*/
public void assingCustomer(Communicator communicator, List<Customer> customerList, boolean deleteExists);
}
实现接口。
/**
*
*/
package com.emerson.etao.service.imp;
import java.sql.SQLException;
import java.util.List;
import com.emerson.etao.dao.IBaseDao;
import com.emerson.etao.dao.IDaoFactory;
import com.emerson.etao.service.IBaseService;
/**
* 业务层实现类基类
*
* 为了降低与数据访问层的耦合，在构造函数中传入DaoFactory接口用于创建具体的数据访问对象实例
*
* @author Chris Mao(Zibing)
*
*/
public abstract class BaseServiceImp<T> implements IBaseService<T> {
private IBaseDao<T> dao = null;
protected IBaseDao<T> getDao() {
return this.dao;
}
/**
*
* @param factory 降低耦合，传入DaoFactory接口
* @see IDaoFactory
*/
public BaseServiceImp(IDaoFactory<T> factory) {
super();
this.dao = factory.getDao();
}
@Override
public long insert(T entity) {
try {
return this.getDao().insert(entity);
} catch (SQLException e) {
e.printStackTrace();
}
return 0;
}
@Override
public int update(long id, T entity) {
try {
return this.getDao().update(id, entity);
} catch (SQLException e) {
e.printStackTrace();
}
return 0;
}
@Override
public int delete(long id) {
try {
return this.getDao().delete(id);
} catch (SQLException e) {
e.printStackTrace();
}
return 0;
}
@Override
public List<T> getAll() {
try {
return this.getDao().getAll();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public T getById(long id) {
try {
return this.getDao().getById(id);
} catch (SQLException e1) {
e1.printStackTrace();
}
return null;
}
}
package com.emerson.etao.service.base.imp;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import com.emerson.etao.dao.IDaoFactory;
import com.emerson.etao.entity.base.BusinessApp;
import com.emerson.etao.entity.base.Communicator;
import com.emerson.etao.entity.base.Customer;
import com.emerson.etao.service.base.ICommunicatorService;
import com.emerson.etao.service.imp.BaseServiceImp;
/**
*
* @author Chris Mao(Zibing)
*
*/
public class CommunicatorServiceImp extends BaseServiceImp<Communicator>implements ICommunicatorService {
@Override
public List<Communicator> getAll(Customer customer) {
List<Communicator> result = new ArrayList<Communicator>();
try {
result = this.getDao()
.getAll("SELECT a.* FROM communicator AS a INNER JOIN customer_communicator cc USING(communicator_id) WHERE cc.customer_id = "
+ customer.getCustomerId());
} catch (SQLException e) {
e.printStackTrace();
}
return result;
}
public CommunicatorServiceImp(IDaoFactory<Communicator> factory) {
super(factory);
}
@Override
public void assignBusinessApp(Communicator communicator, List<BusinessApp> appList, boolean deleteExists) {
try {
if (true == deleteExists) {
this.getDao().getStatement().executeUpdate("DELETE FROM communicator_application WHERE communicator_id = " + communicator.getCommunicatorId());
}
if (null == appList || appList.isEmpty()) {
return;
}
PreparedStatement pstmt = this.getDao().getConnection().prepareStatement("INSERT IGNORE INTO communicator_application(communicator_id, application_id, created_time) VALUES(?, ?, ?)");
BusinessApp app = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
Iterator<BusinessApp> ite = appList.iterator();
while (ite.hasNext()) {
app = ite.next();
pstmt.setLong(1, communicator.getCommunicatorId());
pstmt.setLong(2, app.getApplicationId());
pstmt.setString(3, sdf.format(new Date()));
pstmt.executeUpdate();
}
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 为客服人员分配客户
*
* 如果需要删除客服人员名下所有客户，只需将customers设为null或是空列表
*
* @param communicator
* @param apps
* @param deleteExists
*/
@Override
public void assingCustomer(Communicator communicator, List<Customer> customerList, boolean deleteExists) {
try {
if (true == deleteExists) {
this.getDao().getStatement().executeQuery("DELETE FROM customer_communicator WHERE communicator_id = " + communicator.getCommunicatorId());
}
if (null == customerList || customerList.isEmpty()) {
return;
}
PreparedStatement pstmt = this.getDao().getConnection().prepareStatement("INSERT IGNORE INTO customer_communicator(communicator_id, customer_id, created_time) VALUES(?, ?, ?)");
Customer customer = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
Iterator<Customer> ite = customerList.iterator();
while (ite.hasNext()) {
customer = ite.next();
pstmt.setLong(1, communicator.getCommunicatorId());
pstmt.setLong(2, customer.getCustomerId());
pstmt.setString(3, sdf.format(new Date()));
pstmt.executeUpdate();
}
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
DAO层的设计
这里需在为DAO层定义一个通个的基础接口IBaseDao，这里包含了对数据的增、删、改、查基础操作。抽象类BaseDao实现接口IBaseDao，并添加了访问限制为protected的数据库连接对象，方便子类使用。
DAO接口代码。
/**
*
*/
package com.emerson.etao.dao;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
/**
*
* 数据访问层接口
*
* @author Chris Mao(Zibing)
*
*/
public interface IBaseDao<T> {
/**
*
* @return Connection
*/
public Connection getConnection();
/**
*
* @return Statement
*/
public Statement getStatement();
/**
* 将值对象写入到数据表中，并返回其自增ID值
*
* @param entity
* @return 返回新写入记录的自增ID
* @throws SQLException
*/
public long insert(T entity) throws SQLException;
/**
* 将值对象修改后的内容写入到数据表中，并返回其影响的记录笔数
*
* @param id
* @param entity
* @return 返回更新的记录笔数
* @throws SQLException
*/
public int update(long id, T entity) throws SQLException;
/**
* 删除ID值，并返回其删除的记录笔数
*
* @param id
* @return 返回删除的记录笔数
* @throws SQLException
*/
public int delete(long id) throws SQLException;
/**
* 依据Id值到数据表中查询数据，并返回值对象
*
* @param id
* @return
*/
public T getById(long id) throws SQLException;
/**
* 返回数据表中所有记录
*
* @return List<T>
* @throws SQLException
*/
public List<T> getAll() throws SQLException;
/**
* 返回符合条件的所有记录
*
* @param queryStr
* @return List<T>
* @throws SQLException
*/
public List<T> getAll(String queryStr) throws SQLException;
}
抽象工厂接口。
package com.emerson.etao.dao;
/**
* 数据访问类工厂接口
*
* 负责创建具体的数据访问对象实例
*
* @author Chris Mao(Zibing)
*
* @param <T>
*/
public interface IDaoFactory<T> {
/**
* 创建数据访问对象实例
*
* @return
* @see IBaseDao
*/
public IBaseDao<T> getDao();
}
抽象类BaseDao实现接口IBaseDao。
package com.emerson.etao.dao;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.emerson.etao.db.DBUtils;
/**
*
* 数据访问层基类
*
* 所有数据访问对象都需要继承此类
*
* @author Chris Mao(Zibing)
*
*/
public abstract class BaseDao<T> implements IBaseDao<T> {
private static final Logger logger = LoggerFactory.getLogger(BaseDao.class);
public Connection getConnection() {
return DBUtils.getConnection();
}
public Statement getStatement() {
Statement stmt = null;
try {
Connection conn = DBUtils.getConnection();
stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
} catch (SQLException e) {
logger.error("创建 Statement 对象发生错误！！");
e.printStackTrace();
}
return stmt;
}
}
实体类创建工厂接口。
package com.emerson.etao.entity;
import java.sql.ResultSet;
/**
*
* 实体类工厂接口
*
* 所有实体类对象实例需要通过此工厂接口创建
*
* @author Chris Mao(Zibing)
*
*/
public interface IEntityFactory<T> {
/**
* 创建空的实体类
*
* @return
*/
public T createEntity();
/**
* 创建实体类，并将参数rs中的内容赋值到实体类属性当中
*
* @param rs
* @return
*/
public T createEntity(ResultSet rs);
}
具体的DAO对象，继承BaseDao，并实现实体类创建工厂接口。这里使用了内部匿名类实现DAO的抽象工厂接口。
package com.emerson.etao.dao.base;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.emerson.etao.dao.BaseDao;
import com.emerson.etao.dao.IBaseDao;
import com.emerson.etao.dao.IDaoFactory;
import com.emerson.etao.entity.IEntityFactory;
import com.emerson.etao.entity.base.Communicator;
/**
* 客服人员数据访问对象
*
* @author Chris Mao(Zibing)
*
*/
public class CommunicatorDao extends BaseDao<Communicator>implements IEntityFactory<Communicator> {
public static IDaoFactory<Communicator> factory = new IDaoFactory<Communicator>() {
@Override
public IBaseDao<Communicator> getDao() {
return new CommunicatorDao();
}
};
@Override
public Communicator createEntity() {
return new Communicator();
}
@Override
public Communicator createEntity(ResultSet rs) {
Communicator c = this.createEntity();
try {
c.setCommunicatorId(rs.getInt("communicator_id"));
c.setCommunicatorName(rs.getString("communicator_name"));
c.setPhone(rs.getString("phone"));
c.setFax(rs.getString("fax"));
c.setEmail(rs.getString("email"));
c.setReportTo(rs.getInt("report_to"));
c.setReportToName(rs.getString("report_to_name"));
c.setValid(rs.getByte("is_valid"));
c.setCreatedTime(rs.getTimestamp("created_time"));
c.setUpdatedTime(rs.getTimestamp("update_time"));
} catch (SQLException e) {
e.printStackTrace();
}
return c;
}
@Override
public Communicator getById(long id) throws SQLException {
Communicator result = null;
ResultSet rs = this.getStatement().executeQuery("SELECT * FROM vw_communicator WHERE communicator_id = " + id);
while (rs.next()) {
result = this.createEntity(rs);
}
rs.close();
return result;
}
@Override
public long insert(Communicator entity) throws SQLException {
Long newId = (long) 0;
StringBuilder sql = new StringBuilder();
sql.append("INSERT IGNORE INTO communicator");
sql.append("(communicator_name, phone, fax, email, report_to, created_time) ");
sql.append("VALUES(?, ? ,? ,?, ?, ?)");
PreparedStatement pstmt = this.getConnection().prepareStatement(sql.toString(), Statement.RETURN_GENERATED_KEYS);
pstmt.setString(1, entity.getCommunicatorName());
pstmt.setString(2, entity.getPhone());
pstmt.setString(3, entity.getFax());
pstmt.setString(3, entity.getFax());
pstmt.setString(4, entity.getEmail());
pstmt.setInt(5, entity.getReportTo());
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
pstmt.setString(6, df.format(new Date()));
pstmt.executeUpdate();
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
newId = rs.getLong(1);
entity.setCommunicatorId(rs.getInt(1));
// System.out.println("新增客服记录ID为：" + newId);
}
rs.close();
pstmt.close();
return newId;
}
@Override
public int update(long id, Communicator entiry) throws SQLException {
int result = 0;
StringBuffer sql = new StringBuffer();
Communicator c = (Communicator) entiry;
// System.out.println(c);
sql.append("UPDATE communicator");
sql.append(" SET communicator_name = ?, phone = ?, fax = ?, email = ?, report_to = ?, is_valid = ?");
sql.append(" WHERE communicator_id = ?");
PreparedStatement pstmt = this.getConnection().prepareStatement(sql.toString());
pstmt.setString(1, c.getCommunicatorName());
pstmt.setString(2, c.getPhone());
pstmt.setString(3, c.getFax());
pstmt.setString(3, c.getFax());
pstmt.setString(4, c.getEmail());
pstmt.setInt(5, c.getReportTo());
pstmt.setInt(6, c.getIsValid());
pstmt.setLong(7, c.getCommunicatorId());
result = pstmt.executeUpdate();
// System.out.println("更新客服记录数为：" + result);
pstmt.close();
return result;
}
@Override
public int delete(long id) throws SQLException {
int result = 0;
String sql = "DELETE FROM communicator WHERE communicator_id = ?";
PreparedStatement pstmt;
pstmt = this.getConnection().prepareStatement(sql);
pstmt.setLong(1, id);
result = pstmt.executeUpdate();
// System.out.println("删除客服记录数为：" + result);
pstmt.close();
return result;
}
@Override
public List<Communicator> getAll() throws SQLException {
List<Communicator> result = null;
ResultSet rs = this.getStatement().executeQuery("SELECT * FROM vw_communicator");
result = new ArrayList<Communicator>();
while (rs.next()) {
result.add(this.createEntity(rs));
}
rs.close();
return result;
}
@Override
public List<Communicator> getAll(String queryStr) throws SQLException {
List<Communicator> result = new ArrayList<Communicator>();
ResultSet rs = this.getStatement().executeQuery(queryStr);
while (rs.next()) {
result.add(this.createEntity(rs));
}
rs.close();
return result;
}
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
相关推荐
它的分层设计使得系统更易于测试和扩展。 3. MyBatis：MyBatis是一个持久层框架，它简化了SQL操作，将SQL语句与Java代码分离，提供了动态SQL的支持。在CRM系统中，MyBatis作为数据访问层，负责与数据库进行交互，...
本文将深入探讨一个基于Java SSM框架（Spring、Spring MVC、MyBatis）开发的学生籍贯管理系统，理解其设计原理、核心功能及实现技术。 首先，SSM框架是Java Web开发中的主流选择，它由Spring、Spring MVC和MyBatis...
- **清晰的分层**：Spring MVC 明确区分了模型、视图和控制器的功能，提高了代码的可读性和可维护性。 - **灵活性**：Spring MVC 具有高度的灵活性，可以轻松地集成不同的技术栈。 - **强大的功能集**：提供了丰富的...
1. **Spring MVC架构**：了解Spring MVC的分层结构，包括DispatcherServlet、Controller、Model、View和ViewModel等核心组件。 2. **MVC模式**：学习Model-View-Controller设计模式，理解它如何帮助分离业务逻辑、...
1. **MVC架构模式**：Spring MVC 提供了一个清晰的分层架构，使得开发者可以独立地处理应用程序的业务逻辑、数据访问和用户界面。模型层负责业务逻辑，视图层负责呈现数据，控制器层则协调这两个部分，处理用户的...
《Spring MVC MYBatis企业应用实战+源码》是一份深度探讨如何在企业环境中整合并高效使用Spring MVC和MyBatis两大主流Java框架的资源包。这个资源包含了一本PDF电子书《spring+mybatis企业应用实战》以及配套的源...
1. **Spring MVC**：Spring MVC 提供了一个分层架构，包括 DispatcherServlet、Model、View 和 Controller。DispatcherServlet 负责请求分发，Controller 处理业务逻辑，Model 存储数据，View 负责展示。通过注解...
总的来说，这个“Java Spring网上图书销售系统”虽然只是一个未完成的示例，但它涵盖了Spring框架在实际开发中的多个关键方面，包括依赖注入、MVC架构、事务管理、Spring Boot的使用以及数据访问和安全控制。...
在开始Spring MVC的学习之前，首先需要理解MVC设计模式。MVC模式将应用程序分为三个主要部分：Model（模型）负责处理数据和业务逻辑，View（视图）负责显示数据，Controller（控制器）接收用户请求并调用模型进行...
通过这个项目，你可以学习到如何使用 Spring MVC 构建 Web 应用，理解 MVC 设计模式，熟悉 Spring MVC 中的注解驱动编程，以及如何组织和调试一个基于 Spring MVC 的项目。这将是你踏入 Java Web 开发领域的重要一步...
【标题】"libs.zip" 是一个包含JAVA EE（Java企业版）开发中常用框架和库的压缩文件，重点聚焦在MyBatis、Spring和Spring MVC这三个核心组件上。这些技术是构建现代Java后端应用程序的基础，广泛应用于企业级项目。 ...
"毕业设计管理系统java服务端，采用spring mvc" 这个标题指出的是一个基于Java的毕业设计项目，重点在于服务端的实现。Spring MVC是这个系统所采用的技术框架，它是一个用于构建Web应用程序的轻量级、模型-视图-控制...
Spring MVC是Spring框架的一部分，它为构建基于Java的Web应用程序提供了模型-视图-控制器（MVC）架构。这本书通过详实的案例和清晰的解释，使读者能够有效地学习和应用Spring MVC。 首先，我们要了解Spring MVC的...
Java人力资源管理系统是一个典型的Web应用程序，它利用了Spring MVC、Spring 2和Hibernate 3这三大框架的优势，构建出高效、可维护且易于扩展的系统。本文将深入探讨这些技术及其在系统开发中的应用。 首先，Spring...
Spring MVC 是一个基于...在项目开发初始阶段，利用Spring MVC可以快速构建一个健壮的Web架构，提供良好的分层设计，便于团队协作和后续的扩展。通过学习和熟练掌握Spring MVC，开发者能够提高开发效率，降低维护成本。
标题《Pro Spring MVC》指的是一个专注于Java框架Spring MVC的学习资源，旨在帮助开发者掌握使用Spring MVC框架构建企业级Web应用程序的整个过程。Spring MVC是Spring框架中的一个模块，它支持Web应用程序的构建，...
Spring MVC是Spring框架的一个模块，专门用于构建Web应用程序，而Hibernate则是一个流行的Java对象关系映射（ORM）工具，用于简化数据库操作。 **Spring MVC 概述** Spring MVC是一个基于模型-视图-控制器（MVC）...
【JakartaEE Spring MVC】是Java企业级应用开发的一个重要组成部分，它结合了 JakartaEE（以前称为Java EE）的框架能力和Spring MVC的轻量级控制反转（IoC）与依赖注入（DI）特性，提供了高效且灵活的Web应用程序...
总结来说，Spring MVC框架以其基于IoC的配置、强大的扩展性、清晰的MVC分层和与Spring其他组件的深度集成，成为了现代Java web开发的首选。尽管在某些方面可能不如Webwork2或Struts直接易用，但其灵活性和可扩展性使...