fuliangliang的Blog

合抱之木，生于毫末；九层之台，起于累土；千里之行，始于足下。

用户操作

[即时聊天] [发私信] [加为好友]

fuliangID：fuliangliang

共65463次访问，排名1598好友1人，关注者3人

fuliangliang的文章

原创 100 篇

翻译 0 篇

转载 25 篇

评论 29 篇

fuliang的公告

我的联系方式:20542606

Email:fuliangliang@gmail.com

最近评论

topgunqq：条理清楚,简单易学.比网上其他例子要好一些.至少按照楼主写的过程,我这个初学者实验成功了!

marshluca：恭喜～～
请问有没rails 做的项目，比方blog？
marshluca@gmail.com

chucai：写的非常的好，仔细的拜读了。思路很清晰。考虑的问题也比较全面。

tbsc3：我也遇到了这个问题，如果配1 M就有用，大于2M就还是默认的不知道你有没有解决呀，教教我

文章分类

收藏

相册

净月潭一日游

页面图片

日历

文章收藏

我的JavaEye博客

存档

软件项目交易

订阅我的博客

Java大作业----三层的架构图书管理系统收藏

新一篇: 从源码看spring applicationContext在web容器中加载过程 | 旧一篇: Java EE/J2EE面向对象编程之道

（由于忙于考研没有进行很好的测试，功能不够全，bug在所难免，望见谅）

LibraryManageSystem整体设计说明

LibraryManageSystem 使用了三层的架构：数据访问(Data acess)层、业务（business）层、视图（View）层。

数据访问层：使用JDBC来访问数据库，并对jdbc进行了简单的封装，使用Template mothod模式和回调接口大大减少了对jdbc的低级操作。其中JdbcTemplate类提供了使用jdbc访问数据库的模板，提供了queryForObject和queryForList方法来分别获取查询到的对象和对象的聚集，execute方法来更新、插入、删除操作。提供了RowCallBackHandler接口，可以通过实现该接口来提供对查询一行的回调处理，使用PreparedStatementCallBack回调接口，来提供对PreparedStatement参数的设置，提供了ORMaping接口，通过实现该接口可以很容易实现关系数据库与domain对象的映射，并产生可重用的逻辑。使用Dao模式和AbstractFactory模式对数据访问层进行封装，可以轻易实现数据库间的移植。

业务层：业务层实现了LibraryManageSystem的各项服务，通过业务层使得视图（View）层不依赖于具体的数据访问(Data acess)层的实现。

View层：对MVC进行了清晰地划分。领域对象作为Model,使用java Swing实现了view，

使用ActionLisenter和Controller来实现controller。Controller接口使用命令模式，通过实现该接口来封装对业务的执行并获取执行的结果。真正的控制器其实是ActionLisenter,通过它来监听事件的发生，并分发对命令，并将该命令封装成Controller的某个实现类的对象，执行业务方法，获取执行结果，并将结果显示在view上。

LibraryManageSystem是一个松耦合的系统，并且可以使得数据访问(Data acess)层、业务（business）层可以轻易的被重用与替换，可以使用其他的view技术（如jsp）来复用这两层。提供了对jdbc进行的简单的封装的基础设施，可以在其他项目中重用并扩展。

源码如下：

对jdbc进行封装的部分：

//JdbcTemplate.java
package edu.jlu.fuliang.library.jdbc;

import java.util.ArrayList;
import java.util.List;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcTemplate {

       public List query(String sql,RowCallBackHandler handler){
              Connection connection = JdbcUtils.createConnection();
              PreparedStatement ps = JdbcUtils.createPreparedStatement(sql,connection);
              ResultSet rs = null;
              List list = new ArrayList();
              try {
                     rs = ps.executeQuery();
                     while(rs.next()){
                            list.add(handler.processRow(rs));
                     }
              } catch (SQLException e) {
                     e.printStackTrace();
              }finally{
                     JdbcUtils.closeStatement(ps);
                     JdbcUtils.relaseConnection(connection);
              }
              return list;
       }

       public Object queryForObject(String sql,RowCallBackHandler handler){
              Connection connection = JdbcUtils.createConnection();
              PreparedStatement ps = JdbcUtils.createPreparedStatement(sql,connection);
              ResultSet rs = null;
              Object o = null;
              try {
                     rs = ps.executeQuery();
                     rs.next();
                     o = handler.processRow(rs);
              } catch (SQLException e) {
                     e.printStackTrace();
              }finally{
                     JdbcUtils.closeStatement(ps);
                     JdbcUtils.relaseConnection(connection);
              }
              return o;
       }

       public void executeUpdate(String sql,PreparedStatementCallBack pareparedStatementCallBack){
              Connection connection = JdbcUtils.createConnection();
              PreparedStatement ps = JdbcUtils.createPreparedStatement(sql,connection);
              try {
                     pareparedStatementCallBack.doInStatement(ps);
                     ps.executeUpdate();
              } catch (SQLException e) {
                     e.printStackTrace();
              }finally{
                     JdbcUtils.closeStatement(ps);
                     JdbcUtils.relaseConnection(connection);
              }
       }
}
//回调接口RowCallBackHandler
package edu.jlu.fuliang.library.jdbc;

import java.sql.ResultSet;

public interface RowCallBackHandler {
public Object processRow(ResultSet rs);
}
///回调接口PreparedStatementCallBack
package edu.jlu.fuliang.library.jdbc;

import java.sql.PreparedStatement;
import java.sql.SQLException;

public interface PreparedStatementCallBack {
       public void doInStatement(PreparedStatement stmt)throws SQLException;
}
//ORMaping接口
package edu.jlu.fuliang.library.jdbc;

import java.sql.ResultSet;

public interface ORMaping {
       public Object mapping(ResultSet rs,Object o);
}
//JdbcUtils.java
package edu.jlu.fuliang.library.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcUtils {

       public static Connection createConnection(){//为了简单，进行了硬编码
              String user = "root";
              String passwd = "123456";
           String url = "jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=gb2312";
           Connection connection = null;
           try{
              Class.forName("com.mysql.jdbc.Driver").newInstance();
              connection = DriverManager.getConnection(url,user,passwd);
           }
            catch(Exception e){
                  e.printStackTrace();
           }
            return connection;
       }

       public static PreparedStatement createPreparedStatement(String sql,Connection connection){
              PreparedStatement stmt = null;
              try{
              stmt = connection.prepareStatement(sql);
           }catch(Exception e){
                  e.printStackTrace();
           }
           return stmt;
       }

       public static void closeStatement(Statement s){
              try {
                     s.close();
              } catch (SQLException e) {
                     e.printStackTrace();
              }
       }

       public static void relaseConnection(Connection connection){
              try {
                     connection.close();
              } catch (SQLException e) {
                     e.printStackTrace();
              }
       }
}
//以下是数据访问对象：
//BorrowerDao.java

package edu.jlu.fuliang.library.dao;

import edu.jlu.fuliang.library.domain.Borrower;

public interface BorrowerDao {
       public Borrower queryByLastName(String lastName);
       public void updateBorrower(Borrower borrower);
       public void insertBorrower(Borrower borrower);
       public void deleteBorrowerByLastName(String lastName);
}
// BookDao.java
package edu.jlu.fuliang.library.dao;

import java.util.List;
import edu.jlu.fuliang.library.domain.Book;

public interface BookDao {
public Book queryByTitle(String title);
public List queryByAuthor(String author);
public List queryByBorrowerLastName(String firstName);
public void updateBook(Book book);
public void insertBook(Book book);
public void deleteBookByTile(String title);
}
// BorrowOrReturnDao.java
package edu.jlu.fuliang.library.dao;

public interface BorrowOrReturnDao {
       public void borrowBook(String borrowerLastName,String bookTile);
       public void returnBook(String borrowerLastName,String bookTile);
}
//抽象工厂：
package edu.jlu.fuliang.library.dao;

public interface DaoFactory {
       public BookDao createBookDao();
       public BorrowerDao createBorrowerDao();
       public BorrowOrReturnDao createBorrowOrReturnDao();
}
//具体工厂：
package edu.jlu.fuliang.library.dao;

import edu.jlu.fuliang.library.dao.mysql.BookDaoImpl;
import edu.jlu.fuliang.library.dao.mysql.BorrowerDaoImpl;

public class MysqlDaoFactory implements DaoFactory{

       public BookDao createBookDao() {
              return new BookDaoImpl();
       }

       public BorrowerDao createBorrowerDao() {
              return new BorrowerDaoImpl();
       }
       public BorrowOrReturnDao createBorrowOrReturnDao() {
              return new BorrowOrReturnDaoImpl();
       }
}
//BookDao的具体实现：
//BookDaoImpl.java
package edu.jlu.fuliang.library.dao.mysql;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import edu.jlu.fuliang.library.dao.BookDao;
import edu.jlu.fuliang.library.domain.Book;
import edu.jlu.fuliang.library.jdbc.*;

public class BookDaoImpl implements BookDao{
       private JdbcTemplate jdbcTemplate = new JdbcTemplate();

       public Book queryByTitle(String title) {
              String sql = "select * from book where title = "+title;
              return (Book)jdbcTemplate.queryForObject(sql,new RowCallBackHandler(){
                     public Object processRow(ResultSet rs) {
                            BookMaping map = new BookMaping();
                            Book book = (Book)map.mapping(rs,new Book());
                         return book;
                     }
              });
       }

       public List queryByAuthor(String author) {
              String sql = "select * from book where author = "+author;
              return jdbcTemplate.query(sql,new RowCallBackHandler(){
                     public Object processRow(ResultSet rs) {
                            BookMaping map = new BookMaping();
                            Book book = (Book)map.mapping(rs,new Book());
                            return book;
                     }
              });
       }
//Borrower的具体实现：
//BookDaoImpl.java
package edu.jlu.fuliang.library.dao.mysql;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import edu.jlu.fuliang.library.dao.BorrowerDao;
import edu.jlu.fuliang.library.domain.Borrower;
import edu.jlu.fuliang.library.jdbc.JdbcTemplate;
import edu.jlu.fuliang.library.jdbc.PreparedStatementCallBack;
import edu.jlu.fuliang.library.jdbc.RowCallBackHandler;

public class BorrowerDaoImpl implements BorrowerDao{
       private JdbcTemplate jdbcTemplate = new JdbcTemplate();

       public Borrower queryByLastName(String lastName) {
              String sql = "select * from borrower where lastName = " + lastName;
              return (Borrower)jdbcTemplate.queryForObject(sql,new RowCallBackHandler(){
                     public Object processRow(ResultSet rs) {
                            BorrowerMaping borrowerMaping = new BorrowerMaping();
                            return borrowerMaping.mapping(rs,new Borrower());
                     }
              });
       }

       public void updateBorrower(final Borrower borrower) {
              String sql = "update borrower set lastname = ?,firstname=?" +
                            ",address =?,city =?,zip=?,state=? where lastname = ?";
              jdbcTemplate.executeUpdate(sql,new PreparedStatementCallBack(){
                     public void doInStatement(PreparedStatement stmt) throws SQLException {
                            stmt.setString(1,borrower.getLastName());
                            stmt.setString(2,borrower.getFirstName());
                            stmt.setString(3,borrower.getAddress());
                            stmt.setString(4,borrower.getCity());
                            stmt.setString(5,borrower.getZip());
                            stmt.setString(6,borrower.getState());
                            stmt.setString(7,borrower.getLastName());
                     }
              });

       }

       public void insertBorrower(final Borrower borrower) {
              String sql = "insert into borrower values(?,?,?,?,?,?)";
              jdbcTemplate.executeUpdate(sql,new PreparedStatementCallBack(){
                     public void doInStatement(PreparedStatement stmt) throws SQLException {
                            stmt.setString(1,borrower.getLastName());
                            stmt.setString(2,borrower.getFirstName());
                            stmt.setString(3,borrower.getAddress());
                            stmt.setString(4,borrower.getCity());
                            stmt.setString(5,borrower.getZip());
                            stmt.setString(6,borrower.getState());
                     }
              });
       }

       public void deleteBorrowerByLastName(final String lastName) {
              String sql = "delete from borrower where lastName = ?";
              jdbcTemplate.executeUpdate(sql,new PreparedStatementCallBack(){

                     public void doInStatement(PreparedStatement stmt) throws SQLException {
                            stmt.setString(1,lastName);
                     }
              });
       }

}
// BorrowOrReturnDaoImpl.java
package edu.jlu.fuliang.library.dao.mysql;

import java.sql.PreparedStatement;
import java.sql.SQLException;

import edu.jlu.fuliang.library.dao.BorrowOrReturnDao;
import edu.jlu.fuliang.library.jdbc.JdbcTemplate;
import edu.jlu.fuliang.library.jdbc.PreparedStatementCallBack;

public class BorrowOrReturnDaoImpl implements BorrowOrReturnDao{
       private JdbcTemplate jdbcTemplate = new JdbcTemplate();

       public void borrowBook(final String borrowerLastName, final String bookTitle) {
              String sql = "insert into book_borrower values(?,?)";
              jdbcTemplate.executeUpdate(sql,new PreparedStatementCallBack(){
                     public void doInStatement(PreparedStatement stmt) {
                            try{
                                   stmt.setString(1,borrowerLastName);
                                   stmt.setString(2,bookTitle);
                            }catch(SQLException e){
                                   e.printStackTrace();
                            }
                     }
              });
       }

       public void returnBook(final String borrowerLastName, final String bookTitle) {
              String sql = "delete from book_borrower where lastname = ?,title = ?";
              jdbcTemplate.executeUpdate(sql,new PreparedStatementCallBack(){
                     public void doInStatement(PreparedStatement stmt) {
                            try{
                                   stmt.setString(1,borrowerLastName);
                                   stmt.setString(2,bookTitle);
                            }catch(SQLException e){
                                   e.printStackTrace();
                            }
                     }
              });
       }
}
//book的ORMaping的实现：
// BookMaping.java
package edu.jlu.fuliang.library.dao.mysql;

import java.sql.ResultSet;
import java.sql.SQLException;

import edu.jlu.fuliang.library.domain.Book;
import edu.jlu.fuliang.library.jdbc.ORMaping;

public class BookMaping implements ORMaping{

       public Object mapping(ResultSet rs, Object o) {
              Book book = (Book)o;
              try {
                     book.setTitleName(rs.getString("titleName"));
                     book.setAuthor(rs.getString("author"));
                     book.setISBN(rs.getString("isbn"));
                     book.setType(rs.getInt("type"));
                     book.setItemsAvailable(rs.getInt("itemAvailable"));
              } catch (SQLException e) {
                     e.printStackTrace();
              }
              return book;
       }

}
////borrower的ORMaping的实现：
// BorrowerMaping.java
package edu.jlu.fuliang.library.dao.mysql;

import java.sql.ResultSet;
import java.sql.SQLException;

import edu.jlu.fuliang.library.domain.Borrower;
import edu.jlu.fuliang.library.jdbc.ORMaping;

public class BorrowerMaping implements ORMaping{

       public Object mapping(ResultSet rs, Object o) {
              Borrower borrower = (Borrower)o;
              try {
                     borrower.setLastName(rs.getString(1));
                     borrower.setFirstName(rs.getString(2));
                     borrower.setAddress(rs.getString(3));
                     borrower.setCity(rs.getString(4));
                     borrower.setZip(rs.getString(5));
                     borrower.setState(rs.getString(6));
              } catch (SQLException e) {
                     e.printStackTrace();
              }
              return borrower;
       }

}
//业务层：
//Service接口
// Service.java
package edu.jlu.fuliang.library.service;

import java.util.List;

import edu.jlu.fuliang.library.domain.Book;
import edu.jlu.fuliang.library.domain.Borrower;

public interface Service {
        public Book queryBookByTitle(String title);
        public List queryBookByAuthor(String author);
        public List queryBookByBorrowerLastName(String firstName);
        public void updateBook(Book book);
        public void insertBook(Book book);
        public void deleteBookByTile(String title);
        public Borrower queryBorrowerByLastName(String lastName);
        public void updateBorrower(Borrower borrower);
        public void insertBorrower(Borrower borrower);
        public void deleteBorrowerByLastName(String lastName);
        public void borrowBook(String borrowerLastName,String bookTitle);
        public void returnBook(String borrowerLastName,String bookTitle);
}
//Service的具体实现
// LibraryService.java
package edu.jlu.fuliang.library.service;

import java.util.List;

import edu.jlu.fuliang.library.dao.BookDao;
import edu.jlu.fuliang.library.dao.BorrowOrReturnDao;
import edu.jlu.fuliang.library.dao.BorrowerDao;
import edu.jlu.fuliang.library.dao.DaoFactory;
import edu.jlu.fuliang.library.dao.MysqlDaoFactory;
import edu.jlu.fuliang.library.domain.Book;
import edu.jlu.fuliang.library.domain.Borrower;

public class LibraryService implements Service{

       private BookDao bookDao;
       private BorrowerDao borrowerDao;
       private BorrowOrReturnDao borrowOrReturnDao;

       public LibraryService(){
              DaoFactory daoFactory = new MysqlDaoFactory();
              bookDao = daoFactory.createBookDao();
              borrowerDao = daoFactory.createBorrowerDao();
              borrowOrReturnDao = daoFactory.createBorrowOrReturnDao();
       }

       public Book queryBookByTitle(String title) {
              return bookDao.queryByTitle(title);
       }

       public List queryBookByAuthor(String author) {
              return bookDao.queryByAuthor(author);
       }

       public List queryBookByBorrowerLastName(String firstName) {
              return bookDao.queryByBorrowerLastName(firstName);
       }

       public void updateBook(Book book) {
              bookDao.updateBook(book);
       }

       public void insertBook(Book book) {
              bookDao.insertBook(book);
       }

       public void deleteBookByTile(String title) {
              bookDao.deleteBookByTile(title);
       }

       public Borrower queryBorrowerByLastName(String lastName) {
              return borrowerDao.queryByLastName(lastName);
       }

       public void updateBorrower(Borrower borrower) {
              borrowerDao.updateBorrower(borrower);
       }

       public void insertBorrower(Borrower borrower) {
              borrowerDao.insertBorrower(borrower);
       }

       public void deleteBorrowerByLastName(String lastName) {
              borrowerDao.deleteBorrowerByLastName(lastName);
       }

       public void borrowBook(String borrowerLastName, String bookTitle) {
              borrowOrReturnDao.borrowBook(borrowerLastName,bookTitle);
       }

       public void returnBook(String borrowerLastName, String bookTitle) {
              borrowOrReturnDao.returnBook(borrowerLastName,bookTitle);
       }
}
//view层：
//主界面：
package edu.jlu.fuliang.library.view;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

public class LibraryMainFrame extends JFrame{
       private JPanel myPanel = new MyPanel();
       private JMenu functionMenu,infoMenu,maintenanceMenu;
       private JMenuItem lendMenuItem,returnMenuItem;
       private JMenuItem titleMenuItem,borrowerMenuItem,browseAllMenuItem;
       private JMenuItem insertBookMenuItem,updateBookMenuItem;
       private JMenuItem insertBorrowerMenuItem,updateBorrowerMenuItem;

       public LibraryMainFrame(){
              functionMenu = new JMenu("Function");
              infoMenu = new JMenu("Inforation");
              maintenanceMenu = new JMenu("Maintenance");

              lendMenuItem = new JMenuItem("Lend items...");
              returnMenuItem = new JMenuItem("Return items...");
              functionMenu.add(lendMenuItem);
              functionMenu.add(returnMenuItem);

              titleMenuItem = new JMenuItem("Search book...");
              borrowerMenuItem = new JMenuItem("Search Borrower...");
              browseAllMenuItem = new JMenuItem("Browse All...");
              infoMenu.add(titleMenuItem);
              infoMenu.add(borrowerMenuItem);
              infoMenu.add(browseAllMenuItem);

              insertBookMenuItem = new JMenuItem("Insert Title...");
              updateBookMenuItem = new JMenuItem("Update Item...");
              insertBorrowerMenuItem = new JMenuItem("Insert Borrower...");
              updateBorrowerMenuItem = new JMenuItem("Update Borrower...");
              maintenanceMenu.add(insertBookMenuItem);
              maintenanceMenu.add(updateBookMenuItem);
              maintenanceMenu.add(insertBorrowerMenuItem);
              maintenanceMenu.add(updateBorrowerMenuItem);

              JMenuBar menuBar = new JMenuBar();
              menuBar.add(functionMenu);
              menuBar.add(infoMenu);
              menuBar.add(maintenanceMenu);

              setJMenuBar(menuBar);
              add(myPanel);
              setSize(300,300);
              setVisible(true);

              lendMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new BorrowDialog(LibraryMainFrame.this,"Lend book",true);
                     }
              });
              returnMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new ReturnDialog(LibraryMainFrame.this,"Return book",true);
                     }
              });
              titleMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new SearchBookDialog(LibraryMainFrame.this,"Search book",true);
                     }
              });
              borrowerMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new BorrowerInformationDialog(LibraryMainFrame.this,"Borrower Information",true);
                     }
              });
              browseAllMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {

                     }
              });
              insertBookMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new InsertBookDialog(LibraryMainFrame.this,"Insert book dialog",true);
                     }
              });
              updateBookMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new UpdateBookDialog(LibraryMainFrame.this,"Update book dialog",true);
                     }
              });
              insertBorrowerMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new InsertBorrowerDialog(LibraryMainFrame.this,"Insert borrower dialog",true);
                     }
              });
              updateBorrowerMenuItem.addActionListener(new ActionListener(){
                     public void actionPerformed(ActionEvent e) {
                            new UpdateBorrowerDialog(LibraryMainFrame.this,"Update borrower dialog",true);
                     }
              });
       }

       private class MyPanel extends JPanel{
              public void paint(Graphics g){
                     g.setColor(Color.green);
                     g.drawString("Welcome to Library System!",40,40);
              }
       }
       public static void main(String []args){
              LibraryMainFrame mainFrame = new LibraryMainFrame();
              mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       }
}
package edu.jlu.fuliang.library.view;

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

import edu.jlu.fuliang.library.controller.InsertBorrowerController;
import edu.jlu.fuliang.library.domain.Borrower;

public class InsertBorrowerDialog extends JDialog{
       JTextField lastNameField;
       JTextField firstNameField;
       JTextField addressField;
       JTextField cityField;
       JTextField zipField;
       JTextField stateField;
       JButton addButton,exitButton;

       public InsertBorrowerDialog(JFrame f,String s,boolean