服务器端用Servlet响应客户端请求，Gson请求。可以返回多个数据库中的信息

Gson解析工具类GsonUtil，可以实现对象转换为Json字符串，也可以将json字符串转换为object

package gsonutil;


import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

public class GsonUtil<T> {

    private static Gson gson = new Gson();
    public static <T>  String objectToJsonStr(T object)
    {
        String jsonStr;
        jsonStr = gson.toJson(object);
        return jsonStr;
    }
    public static <T> String objectsToJsonStr(List<T> objects)
    {
        String jsonStr;
        jsonStr = gson.toJson(objects);
        return jsonStr;

    }
    public static <T> T jsonStrToObject(String jsonStr,Class<T> cla)
    {
        T object = gson.fromJson(jsonStr,cla);
        return object;
    }
    public static <T> List<T> jsonStrToObjects(String jsonStr,Class<T> cla)
    {

        //json字符串不能为空  

        //json字符串必须为数组节点类型  

        List<T> listT = null;  
        try {  
            //创建泛型对象  
            T t =  cla.newInstance();  
            //利用类加载加载泛型的具体类型  
            Class<T> classT = (Class<T>) Class.forName(t.getClass().getName());  
            List<Object> listObj = new ArrayList<Object>();  
            //将数组节点中json字符串转换为object对象到Object的list集合  
            listObj = new GsonBuilder().create().fromJson(jsonStr, new TypeToken<List<Object>>(){}.getType());  
            //转换未成功  
            if(listObj == null || listObj.isEmpty()) return null;  
            listT = new ArrayList<T>();  
            //将Object的list中的的每一个元素中的json字符串转换为泛型代表的类型加入泛型代表的list集合返回  
            for (Object obj : listObj) {  
                T perT = new GsonBuilder().create().fromJson(obj.toString(), classT);  
                listT.add(perT);  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return listT;  
    }


}

ProductInfo类，get,set方法实现获取产品id，name,path

package bean;

public class ProductInfo {
    private String img;
    private String name;

    private int id;

    public ProductInfo() {

    }

    public ProductInfo( int id,String img, String name) {
        this.img = img;
        this.name = name;

        this.id = id;
    }

    public String getImg() {
        return img;
    }

    public void setImg(String img) {
        this.img = img;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }



}

ProductInfoDao类返回类对象prds，包含了数据库中的产品id，name，path信息

package db;

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

import bean.ProductInfo;

public class ProductInfoDao {


        int id = -1;
        private DBConn db;

        public ProductInfoDao() {
            db = DBConn.getInstance();
        }

        public List<ProductInfo> getProductInfos() throws Exception {
            List<ProductInfo> prds = new ArrayList<ProductInfo>();
            try {
                /*这种结果集不支持,滚动的读去功能所以,如果获得这样一个结果集,只能使用它里面的next()方法,逐个的读去数据.
                 * 所以如果只是想要可以滚动的类型的Result只要把Statement如下赋值就行了.   
                 * Statement st=conn.createStatement(Result.TYPE_SCROLL_INSENITIVE,ResultSet.CONCUR_READ_ONLY);
                 * */
                Connection conn = db.getConnection();
                Statement stat = conn.createStatement();
                ResultSet rs = stat.executeQuery("SELECT * FROM product where prdId <=10");
                while (rs.next())
                {
                  ProductInfo prd = new ProductInfo();
                  prd.setId(rs.getInt(1));
                  prd.setImg(rs.getString(2));
                  prd.setName("haha"+rs.getInt(1));
                  prds.add(prd);
                  System.out.println(prd.getId());
                  System.out.println(prd.getImg());
                  System.out.println(prd.getName());

                }
                stat.close();
                conn.close();
                return prds;


            } catch (SQLException e) {

                System.out.println("查询失败！");

                e.printStackTrace();

            }
            return null;

        }       

        public static void main(String[] args) {
            ProductInfoDao pDao=new ProductInfoDao();
            try {
                pDao.getProductInfos();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

}

DBConn类实现数据库连接

package db;

import java.io.File;
import java.sql.*;

public class DBConn {
    private static DBConn db = null;

    public static DBConn getInstance(){
        if (db == null){
            db = new DBConn();
        }
        return db;
    }

    //初始化数据库
    private DBConn() {

        Connection conn = null;
        //System.out.println(new java.util.Date());

        try {
            conn = getConnection();
            conn.setAutoCommit(false);
            conn.commit();
            conn.close();
        } catch (SQLException e) {
            System.out.println("数据库创建失败！");
            e.printStackTrace();
        }


    }

    //创建数据库连接
    public Connection getConnection()
    {
        try
        {
              String driver = "com.mysql.jdbc.Driver";
            // URL指向要访问的数据库名         
            String url = "jdbc:mysql://127.0.0.1:3306/mall";
            // MySQL配置时的用户名    
            String user = "root";              // MySQL配置时的密码   
            String password = "";
            String sql=null;
            File file=null;
                Class.forName(driver);
             // 连续数据库         
                Connection conn = DriverManager.getConnection(url, user, password);
                if(!conn.isClosed())            
                     System.out.println("数据库连接成功");
            return conn;
        }
        catch(Exception e)
        {
            System.out.println("数据库连接异常");
            e.printStackTrace();
            return null;
        }

    }

/*public static void main(String[] args) {
    DBConn dbConn =new DBConn();
}*/
}

ProductServlet类实现post方法向客户端响应请求

package servlet;

import gsonutil.GsonUtil;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.google.gson.Gson;

import db.ProductInfoDao;
import bean.ProductInfo;

@SuppressWarnings("serial")
public class ProductServlet extends HttpServlet{

    String jsonStr;

    ProductInfo prdInfo = new ProductInfo();
    ProductInfoDao prdDao = new ProductInfoDao();
    Gson gson = new Gson();


    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doPost(req, resp);
    }


    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;Charset=utf-8");
        List<ProductInfo> prds = null;
        try {
            prds = new ProductInfoDao().getProductInfos();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        jsonStr =GsonUtil.objectToJsonStr(prds);
        System.out.println(prds.size());
        for(int i=0;i<prds.size();i++)
        {
            System.out.println(prds.get(i).getId()+"  "+prds.get(i).getImg()+"  "+prds.get(i).getName());
        }
        System.out.println("---------");
        System.out.println(jsonStr);
        resp.getWriter().print(jsonStr);


    }
}

实验结果