xui考试-我的实现情况

一、工程目录:

xui考试-我的实现情况_第1张图片

二、ExamEntity.java的代码:

package com.esen.esexam.entity;

/**
 * exam实体类
 * 
 * @author ligw
 * @since 2019年4月10日
 */
public class ExamEntity {
    private String examId;

    private String examName;

    private String examDate;

    private String examTask;

    private String personalTall;

    /**
     * 获得Id-主键
     * 
     * @return the examId
     */
    public String getExamId() {
        return examId;
    }

    /**
     * 设置Id-主键
     * 
     * @param examId the examId to set
     */
    public void setExamId(String examId) {
        this.examId = examId;
    }

    /**
     * 获得姓名
     * 
     * @return the examName
     */
    public String getExamName() {
        return examName;
    }

    /**
     * 设置姓名
     * 
     * @param examName the examName to set
     */
    public void setExamName(String examName) {
        this.examName = examName;
    }

    /**
     * 获得日期
     * 
     * @return the examDate
     */
    public String getExamDate() {
        return examDate;
    }

    /**
     * 设置日期
     * 
     * @param examDate the examDate to set
     */
    public void setExamDate(String examDate) {
        this.examDate = examDate;
    }

    /**
     * 获得任务
     * 
     * @return the examTask
     */
    public String getExamTask() {
        return examTask;
    }

    /**
     * 设置任务
     * 
     * @param examTask the examTask to set
     */
    public void setExamTask(String examTask) {
        this.examTask = examTask;
    }

    /**
     * 获得自述
     * 
     * @return the personalTall
     */
    public String getPersonalTall() {
        return personalTall;
    }

    /**
     * 设置自述
     * 
     * @param personalTall the personalTall to set
     */
    public void setPersonalTall(String personalTall) {
        this.personalTall = personalTall;
    }

}
三、Server.java的代码:

package com.esen.esexam;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import com.esen.jdbc.ConnectFactoryManager;
import com.esen.jdbc.ConnectFactoryManagerImpl;
import com.esen.jdbc.ConnectionFactory;
import com.esen.jdbc.DefaultConnectionFactory;
import com.esen.jdbc.PoolConnectionFactory;
import com.esen.jdbc.ibatis.SqlMapClientFactory;
import com.esen.vfs2.Vfs2;
import com.esen.vfs2.VfsFactoryDB;
import com.esen.vfs2.VfsMgr;
import com.esen.vfs2.VfsOperator;
import com.esen.vfs2.impl.VfsOperatorImpl;

/**
 * 此对象为单例,通过getInstance方法获取实例
 * 通过该对象获取数据库连接池工厂和VFS实例
 * 
 * @author ligw
 * @since 2019年4月10日
 */
public class Server {

    /**
     * vfs的数据库表
     */
    public static final String VFS_TABLENAME = "TB_VFS";

    private ConnectFactoryManagerImpl cfm = null;

    private Vfs2 vfs;

    private ConnectionFactory factory = null;

    private VfsOperator admin = null;

    /**
     * 初始化一个Server的实例
     */
    private static Server svr = new Server();

    /**
     * 私有化构造方法
     */
    private Server() {
        cfm = new ConnectFactoryManagerImpl();
        DefaultConnectionFactory.set(cfm);
    }

    /**
     * 获得Server实例对象
     * @return
     */
    public static Server getInstance() {
        return svr;
    }

    /**
     * 获取Admin身份的操作者
     * @return
     */
    public synchronized final VfsOperator getVfsOperatorAsAdmin() {
        if (admin == null) {
            admin = new VfsOperatorImpl("admin", true);
        }
        return admin;
    }

    /**
     * 获取VFS实例
     * 使用代码参考
     * @return
     * @throws Exception 
     */
    public synchronized final Vfs2 getVfs() throws Exception {
        if (vfs == null) {
            Vfs2 _vfs = VfsMgr.createVfsInstance();
            if (_vfs == null) {
                ConnectionFactory fct = this.getConnectionFactory();
                cfm.setConnectionFactory("*", fct);
                Properties pp = new Properties();

                SqlMapClientFactory.setFacoty(new SqlMapClientFactory());
                _vfs = VfsFactoryDB.createVfs(fct, VFS_TABLENAME, pp);
            }
            vfs = _vfs;
        }
        return vfs;
    }

    /**
     * 获得ConnectFactoryManager,第二周的orm会使用
     * @return
     */
    public ConnectFactoryManager getConnectFactoryManager() {
        return cfm;
    }

    /**
     * 获取数据库连接池工厂
     * @throws Exception 
     */
    public synchronized final ConnectionFactory getConnectionFactory() throws Exception {
        if (factory == null) {
            InputStream input = Server.class.getResourceAsStream("jdbc.conf");
            try {
                Properties p = new Properties();
                try {
                    p.load(input);
                } catch (IOException e) {
                    throw new RuntimeException("jdbc配置文件读取失败!");
                }
                factory = new PoolConnectionFactory(null, p);
            } finally {
                input.close();
            }
        }
        return factory;
    }
}
四、jdbc.conf的内容:

#charset UTF-8
#Sat Apr 27 11:05:52 GMT 2013
logLevel=DEBUG
catalog=
maxWait=15000
maxActive=80
url=jdbc\:oracle\:thin\:@localhost\:1521\:orcl
username=c##peixun4
password=peixun4
driverClassName=oracle.jdbc.driver.OracleDriver

五、examEntity-mapping.xml的代码:



             bean="com.esen.esexam.entity.ExamEntity">
        
            
        

        
                             captionkey="" type="C" nullable="false" length="10" pk="true" />
                             captionkey="" type="C" nullable="true" length="20" />
                             captionkey="" type="C" nullable="true" length="50" />
                             captionkey="" type="C" nullable="true" length="50" />
                             captionkey="" type="C" nullable="true" length="50" />
        

        
            
        

    

六、ExamDao.java的代码:

package com.esen.esexam.dao;

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

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.esen.esexam.Server;
import com.esen.esexam.entity.ExamEntity;
import com.esen.jdbc.ConnectFactoryManagerImpl;
import com.esen.jdbc.ConnectionFactory;
import com.esen.jdbc.DefaultConnectionFactory;
import com.esen.jdbc.orm.EntityInfoManager;
import com.esen.jdbc.orm.EntityInfoManagerFactory;
import com.esen.jdbc.orm.Session;
import com.esen.jdbc.orm.SessionFactory;
import com.esen.jdbc.orm.SessionFactoryBuilder;
import com.esen.util.StrFunc;
import com.esen.util.UNID;

/**
 * examDao类
 * 
 * 连接数据库,操作数据库的方法
 * @author ligw
 * @since 2019年4月10日
 */
public class ExamDao {
    /**
     * 工厂管理员:entityManager
     */
    private EntityInfoManager entityManager;

    /**
     * 静态的私有对象实例
     */
    private static ExamDao instance;

    /**
     * session工厂:sessionFactory
     */
    private SessionFactory sessionFactory;

    /**
     * 私有化构造方法,初始化
     * 
     * @throws Exception
     */
    private ExamDao() throws Exception {
        load();
    }

    /**
     * 获得单一实例对象,主要线程安全
     * 
     * @return
     * @throws Exception
     */
    public static synchronized ExamDao getInstance() throws Exception {
        if (instance == null) {
            instance = new ExamDao();
        }
        return instance;
    }

    /**
     * 获取Session
     * 
     * @return
     * @throws Exception
     */
    public Session getSession() throws Exception {
        return sessionFactory.openSession();
    }

    /**
     * 初始化,连接池,sessionFactory
     * @throws Exception
     */
    private void load() throws Exception {
        // 创建连接池ConnectionFactory,以及连接池管理对象,将ConnectionFactory放入管理对象中,名称是“*”
        // 以下代码服务器只会创建一次,如果已经创建过连接池,请不要重复创建
        // 定义工厂
        ConnectionFactory fct = Server.getInstance().getConnectionFactory();
        // 定义工厂管理员
        ConnectFactoryManagerImpl fm = new ConnectFactoryManagerImpl();
        // 把工厂标记起来
        fm.setConnectionFactory("*", fct);
        DefaultConnectionFactory.set(fm);

        // 根据xml文件,build解析成实体类的管理对象 EntityInfoManager
        entityManager = EntityInfoManagerFactory.buildFromURL(this.getClass().getResource("examEntity-mapping.xml"));

        // 创建SessionFactory工厂,通过标记来调用工厂
        sessionFactory = SessionFactoryBuilder.build("*", entityManager);
    }

    /**
     * 分页查询exam
     * @param pi 起始数
     * @param ps 单页总数
     * @return
     * @throws Exception
     */
    public List queryExam(String pi, String ps) throws Exception {
        // 字符串转整形转换
        int pageIndex = StrFunc.str2int(pi, 0);
        int pageSize = StrFunc.str2int(ps, 14);
        // 计算查询分页的索引
        int fromNum = pageIndex * pageSize;
        int toNum = (pageIndex + 1) * pageSize;
        Session session = sessionFactory.openSession();
        try {
            Connection conn = session.getConnection();
            try {
                String sql = "select * from (select rownum rn ,examId ,examName, examDate, examTask ,personalTall from exam ) where rn > "
                        + fromNum + " and rn <= " + toNum;
                PreparedStatement statement = conn.prepareStatement(sql);
                try {
                    ResultSet rs = statement.executeQuery();
                    try {
                        List models = new ArrayList();
                        while (rs.next()) {
                            ExamEntity exam = new ExamEntity();
                            exam.setExamId(rs.getString("examId"));
                            exam.setExamName(rs.getString("examName"));
                            exam.setExamDate(rs.getString("examDate"));
                            exam.setExamTask(rs.getString("examTask"));
                            exam.setPersonalTall(rs.getString("personalTall"));
                            models.add(exam);
                        }
                        return models;
                    } finally {
                        rs.close();
                    }
                } finally {
                    statement.close();
                }
            } finally {
                conn.close();
            }
        } finally {
            session.close();
        }
    }

    /**
     * 查询数据的总条数
     * @return
     * @throws SQLException
     * @throws JSONException
     */
    public Object getTotalCount() throws SQLException, JSONException {
        Session session = sessionFactory.openSession();
        try {
            Connection conn = session.getConnection();
            try {
                String sql = "select count(*) from exam";
                PreparedStatement pst = conn.prepareStatement(sql);
                try {
                    ResultSet rs = pst.executeQuery();
                    try {
                        JSONArray ja = new JSONArray();
                        while (rs.next()) {
                            JSONObject jo = new JSONObject();
                            jo.put("totalCount", rs.getString(1));
                            ja.put(jo);
                        }
                        return ja;
                    } finally {
                        rs.close();
                    }
                } finally {
                    pst.close();
                }
            } finally {
                conn.close();
            }
        } finally {
            session.close();
        }
    }

    /**
     * 添加任务
     * @param examName 姓名
     * @param examDate 日期
     * @param examTask 任务
     * @param personalTall  自述
     */
    public void addTask(String examName, String examDate, String examTask, String personalTall) throws SQLException {
        String examId = UNID.randomID().substring(0, 3);
        String insertTask = "insert into exam values ('" + examId + "', '" + examName + "', '" + examDate + "', '"
                + examTask + "', '" + personalTall + "')";
        Session session = sessionFactory.openSession();
        try {
            Connection conn = session.getConnection();
            try {
                Statement st = conn.createStatement();
                try {
                    st.addBatch(insertTask);
                    st.executeBatch();
                } finally {
                    st.close();
                }
            } finally {
                conn.close();
            }
        } finally {
            session.close();
        }
    }

    /**
     * 根据examId删除exam数据
     * @param examIds 前端勾选数据的examId
     * @throws SQLException
     */
    public void deleteExam(String examIds) throws SQLException {
        String[] examIdss = examIds.split(",");
        for (int i = 0; i < examIdss.length; i++) {
            String deleteExam = "delete from exam where examId = '" + examIdss[i] + "'";
            Session session = sessionFactory.openSession();
            try {
                Connection conn = session.getConnection();
                try {
                    Statement st = conn.createStatement();
                    try {
                        st.addBatch(deleteExam);
                        st.executeBatch();
                    } finally {
                        st.close();
                    }
                } finally {
                    conn.close();
                }
            } finally {
                session.close();
            }
        }

    }

}
七、ActionExamWelcome.java的代码:

package com.esen.esexam.action;

import java.util.List;

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

import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.esen.esexam.dao.ExamDao;
import com.esen.esexam.entity.ExamEntity;
import com.esen.util.ExceptionHandler;
import com.esen.util.StrFunc;
import com.esen.weblib.ClientResult;
import com.esen.weblib.action.Action_Js;

/**
 * examAction类 
 * 
 * 负责返回视图 负责接受前台的js请求
 * @author ligw
 * @since 2019年4月10日
 */
@Controller
@RequestMapping("/examWelcome")
public class ActionExamWelcome extends Action_Js {
    /**
     * 返回前台页面
     */
    @Override
    public String execute(HttpServletRequest req, HttpServletResponse res) throws Exception {
        // 参数cmd 是判断分支的参数,不同参数走不同的分支处理
        String cmd = req.getParameter("cmd");
        // 如果cmd为空,返回主界面
        if (StrFunc.isNull(cmd)) {
            return examWelcome(req, res);
        }
        // 调用父类的execute方法,以便跳到下面的jsexecute方法
        return super.execute(req, res);
    }

    /**
     * 该方法主要负责前台的一些js请求,将请求数据返回前台
     */
    @Override
    protected String jsexecute(HttpServletRequest req, ClientResult result) throws Exception {
        try {
            // 参数cmd 是判断分支的参数,不同参数走不同的分支处理
            String cmd = req.getParameter("cmd");
            // 查询exam数据
            if (StrFunc.compareStrIgnoreCase(cmd, "getExam")) {
                String pageindex = req.getParameter("pageIndex");
                String pagesize = req.getParameter("pageSize");
                ExamDao ed = ExamDao.getInstance();
                List models = ed.queryExam(pageindex, pagesize);
                JSONArray array = new JSONArray();
                for (ExamEntity exam : models) {
                    JSONObject bj = new JSONObject();
                    bj.put("examId", exam.getExamId());
                    bj.put("examName", exam.getExamName());
                    bj.put("examDate", exam.getExamDate());
                    bj.put("examTask", exam.getExamTask());
                    bj.put("personalTall", exam.getPersonalTall());
                    array.put(bj);
                }
                result.getWriter().write(array.toString());
            }
            // 查询数据的总条数
            else if (StrFunc.compareStrIgnoreCase(cmd, "getCountExam")) {
                ExamDao ed = ExamDao.getInstance();
                result.getWriter().write(ed.getTotalCount().toString());
            }
            // 添加数据
            else if (StrFunc.compareStrIgnoreCase(cmd, "addTask")) {
                String examName = req.getParameter("examName");
                String examDate = req.getParameter("examDate");
                String examTask = req.getParameter("examTask");
                String personalTall = req.getParameter("personalTall");
                ExamDao ed = ExamDao.getInstance();
                ed.addTask(examName, examDate, examTask, personalTall);
            }
            // 根据examId删除数据
            else if (StrFunc.compareStrIgnoreCase(cmd, "deleteExam")) {
                String examIds = req.getParameter("id");
                ExamDao ed = ExamDao.getInstance();
                ed.deleteExam(examIds);
            }
        } catch (Exception e) {
            ExceptionHandler.rethrowRuntimeException(e);
        }
        return null;
    }

    /**
     * 返回xuiExam.ftl页面
     * @param req
     * @param res
     * @return
     */
    private String examWelcome(HttpServletRequest req, HttpServletResponse res) {
        return "esexam/xuiExam";
    }

}
八、xuiExam.flt的代码:

<@comm.page>
<@comm.head title="xuiExam">


<@comm.body>

    style="width: 85%; height: 85%; border: 2px solid black; margin: 40px 100px;">


            
       
       
       
              
       
       
       
          
           
       
       
       
         
           
       

九、exam.js 的代码:

/**
 * exam类对象的封装
 * 
 * @param wnd
 * @param parentElement
 * @returns
 */
function xuiExam(wnd, parentElement) {
    XComponent.call(this, wnd, parentElement);
    this._initDom();
}

extendClass(xuiExam, XComponent, "xuiExam");// xuiExam继承XComponent

/**
 * 初始化dom结构
 */
xuiExam.prototype._initDom = function() {
    // 记录勾选数据的examId
    this.examIds = [];
    // 定义xcoolbar
    var barDiv = this.parentElement.appendChild(this.doc.createElement("div"));
    var coolBar = new XCoolBar(this.wnd, barDiv, "100%", "100%");
    var coolDom = coolBar.__getBaseDom();
    // 定义xbutton
    var buttonDiv = this.parentElement.appendChild(this.doc
            .createElement("div"));
    buttonDiv.style.cssText += ";border:2px black solid;";
    this._initAddButton(coolDom);
    this._initDeleteButton(coolDom);
    // 定义数据列表
    var xlistDiv = this.parentElement
            .appendChild(this.doc.createElement("div"));
    xlistDiv.style.cssText += ";border:2px black solid;height:94%;width:100%;";
    this._initXlist(xlistDiv);
}

/**
 * 加载新增button
 */
xuiExam.prototype._initAddButton = function(dom) {
    var xbutton = new XButton(this.wnd, dom, "新增", false);
    var self = this;
    xbutton.setOnClick(function() {
                var dlg = new XDialog("添加任务", "460px", "400px", this.wnd);
                var dom = dlg.getContent();// 获取弹窗的dom
                // 姓名一行
                var div1 = dom.appendChild(this.doc.createElement("div"));
                div1.style.cssText += ";margin: 15px 120px;";
                var span1 = div1.appendChild(this.doc.createElement("span"));
                span1.innerHTML = "*姓名:";
                var input1 = div1.appendChild(this.doc.createElement("input"));
                // 日期一行
                var div2 = dom.appendChild(this.doc.createElement("div"));
                div2.style.cssText += ";margin: 15px 120px;";
                var span2 = div2.appendChild(this.doc.createElement("span"));
                span2.innerHTML = "*时间:";
                // new日期组件
                var date = new XCalendarCombobox(this.wnd, div2, "150px");
                // 任务一行
                var div4 = dom.appendChild(this.doc.createElement("div"));
                div4.style.cssText += ";margin: 15px 120px;";
                var div5 = div4.appendChild(this.doc.createElement("div"));
                div5.style.cssText += ";float: left;";
                var span4 = div5.appendChild(this.doc.createElement("span"));
                span4.innerHTML = "任务:";
                var div6 = div4.appendChild(this.doc.createElement("div"));
                div6.style.cssText += ";float: left;";
                var textarea1 = div6.appendChild(this.doc
                        .createElement("textarea"));
                textarea1.style.cssText += ";height:100px;width:150px;";
                // 自述一行
                var div7 = dom.appendChild(this.doc.createElement("div"));
                div7.style.cssText += ";margin: 15px 120px;";
                var div8 = div7.appendChild(this.doc.createElement("div"));
                div8.style.cssText += ";float: left;";
                var span8 = div8.appendChild(this.doc.createElement("span"));
                span8.innerHTML = "自述:";
                var div9 = div7.appendChild(this.doc.createElement("div"));
                div9.style.cssText += ";float: left;";
                var textarea2 = div9.appendChild(this.doc
                        .createElement("textarea"));
                textarea2.style.cssText += ";height:100px;width:150px;";
                // 确认按钮
                var _btOk = dlg.addButton("确认", null, null, null, true);
                dlg.open();
                _btOk.setOnClick(function() {
                    if (input1.value == "") {
                        showMessage("请输入姓名,谢谢!!!");
                    } else if (date.getDate() == "") {
                        showMessage("请输入日期,谢谢!!!");
                    } else {
                        // 传给服务器的参数
                        var map = new Map();
                        map.put("cmd", "addTask");
                        map.put("examName", input1.value);
                        map.put("examDate", date.getDate());
                        map.put("examTask", textarea1.value);
                        map.put("personalTall", textarea2.value);
                        QueryObj.create(
                                sys.getContextPath() + "examWelcome.do", map,
                                function(query) {
                                    try {                                    
                                        showMessage("添加成功!!!");    
                                        dlg.close();    
                                    } catch (e) {
                                        showError(e);
                                    }
                                });
                    }
                    location.reload(1000);    
                });
                // 取消按钮
                var _btCancel = dlg.addButton("取消");
                _btCancel.setOnClick(function() {
                    dlg.close();
                });
            
            });
}

/**
 * 加载删除button
 */
xuiExam.prototype._initDeleteButton = function(dom) {
    var xbutton = new XButton(this.wnd, dom, "删除", false);
    var self = this;
    xbutton.setOnClick(function() {
        // 删除后台数据
        var map = new Map();
        map.put("cmd", "deleteExam");
        map.put("id", self.examIds);
        // 向服务器请求,异步的
        QueryObj.create(sys.getContextPath() + "examWelcome.do", map, function(
                query) {
            try {
                var cd = new confirmDialog("删除", "确定删除?", true, null);
                showMessage("删除成功!!!");    
                location.reload(10000);
            } catch (e) {
                showError(e);
            }
        });
        
    });
}

/**
 * 初始化xlist
 */
xuiExam.prototype._initXlist = function(dom) {
    var self = this;// 因为在这个地方 this才是bookxtree这个对象
    var columns = [ [ "", "30px" ], [ "姓名", "200px" ], [ "日期", "200px" ],
            [ "任务", "200px" ], [ "自述", "200px" ], [ "操作", "200px" ] ];
    this.xlist = new XList(this.wnd, dom, "100%", "84.5%");
    // 添加复选框,要记得不要再前面的new XList()里头添加columns,要在后面的initwithcolumns()里添加columns
    var cols = [ "ck" ];
    this.xlist.setAdditionalCols(cols);
    this.xlist.initWithColumns(columns);

    // 加载首页数据
    this.queryexam();

    var map = new Map();
    map.put("cmd", "getCountExam");
    // 向服务器请求,异步的
    QueryObj.create(sys.getContextPath() + "examWelcome.do", map, function(
            query) {
        try {
            // 检查返回结果,有异常则抛出来
            query.checkResult;
            // 获取后台结果
            var countExam = query.getResponseJSON();
            var tc = countExam[0].totalCount;

            var userdata = "";

            // 分页条,加载各页图书管理数据
            var bar1 = new XPageBar(dom, // 第一个参数,创建分页条的dom元素
            { // 第二个参数,创建分页的一些信息
                style : 'text', // 'icon'为图标版本分页,'text'为文字链接分页,默认为'text'
                pageSize : 14, // 表示一页显示的行数
                totalCount : tc, // 表示总数,可以为-1表示不确定。总数需要请求后台获得
                pageIndex : 0, // 表示当前显示的是第几页
                hasMoreData : true
            // 表示是否还有更多的数据(当totalCount为-1时,此属性起效)
            },
            // 第三个参数,点击上一页,下一页,翻页的 回调函数
            // pageIndex-第几页;pageSize-每页显示的行数;userdata-外面传进来的参数
            function(pageIndex, pageSize, userdata) {
                // 这是翻页会触发的事件
                // 负责处理,向后台请求数据,获得数据后,将数据加载到前台
                // 传给服务器的参数
                var map = new Map();
                map.put("cmd", "getExam");
                map.put("pageIndex", pageIndex);
                map.put("pageSize", pageSize);
                // 获取选中的items
                var items = self.xlist.getCheckedItems();
                // 点击下一页的时候,获取选中的items,然后获取examId,保存在一个全局变量examIds里
                self.getItems(items);

                // 向服务器请求,异步的
                QueryObj.create(sys.getContextPath() + "examWelcome.do", map,
                        function(query) {
                            try {
                                // 检查返回结果,有异常则抛出来
                                query.checkResult;
                                // 获取后台结果
                                var records = query.getResponseJSON();
                                // 清空上一个xlist的数据
                                self.xlist.clear();
                                // 迭代赋值
                                for (var i = 0; i < records.length; i++) {
                                    var examId = records[i].examId;
                                    var examName = records[i].examName;
                                    var examDate = records[i].examDate;
                                    var examTask = records[i].examTask;
                                    var personalTall = records[i].personalTall;
                                    var row = self.xlist.addRow("", examName,
                                            examDate, examTask, personalTall,
                                            "编辑   删除 ");
                                    row.setUserObj(examId);
                                }
                            } catch (e) {
                                showError(e);
                            }
                        });
            }, userdata // 第四个参数,传到第三个参数回调函数中使用的
            );
        } catch (e) {
            showError(e);
        }
    });
}

/**
 * 加载首页数据
 */
xuiExam.prototype.queryexam = function() {
    var self = this;
    // 生成请求参数
    var map = new Map();
    map.put("cmd", "getExam");
    map.put("pageIndex", 0);
    map.put("pageSize", 14);

    // 向服务器发出请求
    QueryObj.create(sys.getContextPath() + "examWelcome.do", map, function(
            query) {
        try {
            // 检查返回结果,有异常那个就抛出来
            query.checkResult();
            // 获得后台数据
            var arr = query.getResponseJSON();
            // 清空上一个xlist的数据
            self.xlist.clear();
            // 填充xlist
            for (var i = 0; i < arr.length; i++) {
                var examId = arr[i].examId;
                var examName = arr[i].examName;
                var examDate = arr[i].examDate;
                var examTask = arr[i].examTask;
                var personalTall = arr[i].personalTall;
                var row = self.xlist.addRow("", examName, examDate, examTask,
                        personalTall, "编辑  删除 ");
                row.setUserObj(examId);
            }
        } catch (e) {
            showError(e);
        }
    });
}

/**
 * 没有按下一页,选择的时候,就对选中的items,getUserObject 以数组的形式保存,选中的examId
 */
xuiExam.prototype.getItems = function(items) {
    var len = items.length;
    for (var i = 0; i < len; i++) {
        var examId = items[i].getUserObj();
        this.examIds.push(examId);
    }
}
/**
 * 销毁对象
 */
xuiExam.prototype.dispose = function() {

    XComponent.prototype.dispose.call(this);
}

你可能感兴趣的:(xui考试-我的实现情况)