• 我能不能理解成 ssh中service就相当于与jsp+servlet+dao中的servlet???


    转文


    首先解释面上意思,service是业务层,dao是数据访问层。(Data Access Objects) 数据访问对象

      1.Dao其实一般没有这个类,这一般是指java中MVC架构中的model的概念,主要是访问数据库的一些方法。
      2.一般的javaMVC架构中最外层是view也就是页面,control是一些控制后台和页面访问的类,model其实是dao层,但大部分人,会再增加一层service层来提供更为方便的应用
      3.DAO层一般有接口和该接口的实现类! 接口用于规范实现类! 实现类一般用于用于操作数据库! 一般操作修改,添加,删除数据库操作的步骤很相似,就写了一个公共类DAO类 ,修改,添加,删除数据库操作时 直接调用公共类DAO类!



      这个问题我曾经也有过,记得以前刚学编程的时候,都是在service里直接调用dao,service里面就new一个dao类对象,调用,其他有意义的事没做,也不明白有这个有什么用,参加工作久了以后就会知道,业务才是工作中的重中之重。


      我们都知道,标准主流现在的编程方式都是采用MVC综合设计模式,MVC本身不属于设计模式的一种,它描述的是一种结构,最终目的达到解耦,解耦说的意思是你更改某一层代码,不会影响我其他层代码,如果你会像spring这样的框架,你会了解面向接口编程,表示层调用控制层,控制层调用业务层,业务层调用数据访问层。初期也许都是new对象去调用下一层,比如你在业务层new一个DAO类的对象,调用DAO类方法访问数据库,这样写是不对的,因为在业务层中是不应该含有具体对象,最多只能有引用,如果有具体对象存在,就耦合了。当那个对象不存在,我还要修改业务的代码,这不符合逻辑。好比主板上内存坏了,我换内存,没必要连主板一起换。我不用知道内存是哪家生产,不用知道多大容量,只要是内存都可以插上这个接口使用。这就是MVC的意义。


      接下来说你感觉service的意义,其实因为你现在做东西分层次不是那么严格,在一个你们做东西业务本身也少,举个最简单的例子,你做一个分页的功能,数据1000条,你20条在一个页,你可以把这个功能写成工具类封装起来,然后在业务层里调用这个封装的方法,这才是业务里真正干得事,只要没访问数据库的,都要在业务里写。
    再有不明白的追问,这是经验问题,呵呵,其实以后你就会懂。只是刚开始写的代码都是有个请求,我就去数据库取,业务几乎没有。


    比说你现在用的是SSH框架,做一个用户模块:


        1、假设现在你做这个功能会用到user表和权限表,那么你前台的页面访问action,action再去调用用户模块service,用户模块service判断你是操作user表还是权限表,如果你操作的是user表则service的实现类就去调用userDAO。如果是操作的是权限表则调用权限的DAO


        2、也就是说DAO一定是和数据库的每张表一一对应,而service则不是。明白的没?其实你一个项目一个service和一个DAO其实也一样可以操作数据库,只不过那要是表非常多,出问题了,那找起来多麻烦,而且太乱了


       3、好处就是你的整个项目非常系统化,和数据库的表能一致,而且功能模块化,这样以后维护或者改错比较容易,性能也高一些


    按照mvc或spring整体来说感觉就是一一对应的关系.

          UI-->controller(actionservlet)-->model(Bean.class){数据模型,业务逻辑模型}

          表现层-->controller(action)-->service(业务逻辑层)-->Dao(数据访问层)


    MVC:

    其实按照用户请求的执行顺序应该从左向右依次为view-controller-model。

    • 视图层view:用于展示数据,与用户进行交互。
    • 控制层controller:用于分发控制到来的请求,并调用模型层与数据库进行交互,以及将数据返回给视图层展示。
    • 模型层model:数据模型,它与数据库进行交互,进行CURD操作。

    当用户通过浏览器的web界面发起查询请求时,首先会被控制层controller分发,然后会调取相应的model层进行数据库查询。然后model层再将数据库查询到的数据返回给控制层,控制层再将其返回view层,view层web页面中进行显示。


    view-controller-service-dao

    以前,我一直认为可以直接在控制层就调用model层来进行数据库的交互。因为之前接触到的项目业务逻辑比较简单,所以直接在控制层就将很多工作都完成了。当我慢慢理解了MVC分层架构后,我觉得这是不严谨的,耦合性太强了,违背了MVC的初衷,即解耦。所以随着MVC学习的深入,慢慢地又加入到了业务层service和数据访问层dao。那么上述的情景就可以有如下的表示:

    • 视图层view:用于展示数据,与用户进行交互。
    • 控制层controller:用于分发控制到来的请求,并将请求分发给相应的业务层。以及将数据返回给视图层展示。
    • 业务层service:业务处理,调用数据访问层与数据库进行交互。
    • 数据访问层dao:它与数据库进行交互,封装了对数据库的CURD操作。

    当请求来了,controller就会将相应的请求分发到相应的service层,在service层中再调用dao层进行数据库交互。这里的dao层其实就是之前的model层,封装了对数据库的操作。这样一来,就把业务处理逻辑从controller中分离出来,从而实现了解耦。

    通过网上的了解,在有些项目中,其实也是没有完全按照分层进行架构,省略了service层,直接将业务逻辑与数据访问揉在了一起,这样其实是不便于扩展的,为了项目的架构清晰,易于管理,方便扩展,还是应该按照分层的架构来构建项目。


    转载 :http://cache.baiducontent.com/c?m=9d78d513d98203ef03b1c1690c66c0171b43f7172ba6d10208d08449e33b1f10506793ac51240770d4d20d6616df4f4beb802102321456b38cb8885daaba866f6fd6286e365ac45613a004b29b18789437902db8ee4fbbadf045cff994ce8e0e139112127df4afd8071d478a29ab456fb4bbcf1f530c4be4ac2d63f55d7c2f9f2541&p=826ac54ad6c040be0be29612586491&newp=8b2a9714cdaf07ff57ed977f5952cb231610db2151d4d5166b82c825d7331b001c3bbfb423241604d1c47a640aa94c5ae9f53673340225a3dda5c91d9fb4c57479d93c5836&user=baidu&fm=sc&query=spring%C0%EF%C3%E6mvc%D4%F5%C3%B4%B7%D6%B2%E3&qid=91667ff20000bc63&p1=2


    概述

    一个典型的页面浏览行为在程序端的流程是这样的:

    1. 控制器最先被调用,并被赋予外部输入
    2. 控制器根据外部输入向模型请求数据
    3. 模型从数据库获取数据并发送数据到控制器
    4. 控制器处理该数据并发送封装好的数据到视图
    5. 视图根据接到的数据最终展示页面给用户浏览

    使用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;
    	}
    }
    
  • 相关阅读:
    20 个 .NET 6 新增的 API
    巅峰对决!Spring Boot VS .NET 6
    【.NET 遇上 GraphQL】 ChilliCream 平台介绍
    使用 CliWrap 让C#中的命令行交互举重若轻
    微软开源的Web测试和自动化神器 Playwright
    GraphQL 到底有什么魔力?
    win切换jdk版本
    WebBug Java漏洞靶场 Java代码审计
    Docker镜像安全的一些(初级)检测方法
    权限安全管控的设计想法
  • 原文地址:https://www.cnblogs.com/Willie-WangLiang/p/7210433.html
Copyright © 2020-2023  润新知