JavaEE练习项目--快递e栈（第三天）

最新推荐文章于 2021-07-24 12:20:11 发布
最新推荐文章于 2021-07-24 12:20:11 发布
阅读量449 收藏 4
点赞数 1
分类专栏： 项目分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44141495/article/details/108910647
版权

JavaEE练习项目–快递e栈（第三天）

内容地址
需求分析链接地址
建表，工具类书写链接地址
Jdbc工具类链接地址
三层架构，阿里云短信链接地址
前端Ajax链接地址

我们的项目使用原生的JDBC+Servlet来就进行开发，对于我们的Servlet，我们已经仿照了springMVC的做法来进行优化，我们就可以集中注意力在业务的开发上了！

连接池

DruidUtil

简单的调用了Druid连接池，将获取连接和关闭的方法都进行了封装。

public class DruidUtil {

    /**
     * 数据源
     */
    private static DataSource dataSource;
    static{
        try {
            Properties ppt = new Properties();
            InputStream stream = DruidUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            ppt.load(stream);
            dataSource = DruidDataSourceFactory.createDataSource(ppt);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据源
     *
     * @return {@link DataSource}
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 获取连接
     * 从连接池中取出一个连接给用户
     *
     * @return {@link Connection}
     */
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }


    /**
     * 关闭
     *
     * @param conn  康涅狄格州
     * @param state 状态
     * @param rs    rs
     */
    public static void close(Connection conn, Statement state, ResultSet rs){
        try {
            if(rs!=null) {
                rs.close();
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        try {
            if(state!=null) {
                state.close();
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        try {
            if(conn!=null) {
                conn.close();
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
    }
}

配置文件

url=jdbc:mysql:///express?useUnicode=true&characterEncoding=utf-8
username=root
password=
driverClassName=com.mysql.jdbc.Driver
initialSize=5
maxActive=10
minIdle=5
maxWait=3000

Jdbc工具

对于我们的原生的JDBC我们也需要进行优化

原来的代码：

我们已将将连接的获取和关闭方法封装给了DruiUtil这个工具类，但是我们还是免不了重复的代码：

  • 每个方法都有获取连接和关闭连接的方法
  • 每个方法都要预编译SQL，执行查询方法，然后结果集封装为对象
  • 每个方法还会要进行异常处理
 @Override
    public List<Map<String, Integer>> console() {
        ArrayList<Map<String,Integer>> data = new ArrayList<>();
        //1.    获取数据库的连接
        Connection conn = DruidUtil.getConnection();
        PreparedStatement state = null;
        ResultSet result = null;
        //2.    预编译SQL语句
        try {
            state = conn.prepareStatement(SQL_CONSOLE);
            //3.    填充参数(可选)
            //4.    执行SQL语句
            result = state.executeQuery();
            //5.    获取执行的结果
            if(result.next()){
                int data1_size = result.getInt("data1_size");
                int data1_day = result.getInt("data1_day");
                int data2_size = result.getInt("data2_size");
                int data2_day = result.getInt("data2_day");
                Map data1 = new HashMap();
                data1.put("data1_size",data1_size);
                data1.put("data1_day",data1_day);
                Map data2 = new HashMap();
                data2.put("data2_size",data2_size);
                data2.put("data2_day",data2_day);
                data.add(data1);
                data.add(data2);
            }
            //6.    资源的释放
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            DruidUtil.close(conn,state,result);
        }

        return data;
    }

    /**
     * 用于查询所有快递
     *
     * @param limit      是否分页的标记，true表示分页。false表示查询所有快递
     * @param offset     SQL语句的起始索引
     * @param pageNumber 页查询的数量
     * @return 快递的集合
     */
    @Override
    public List<Express> findAll(boolean limit, int offset, int pageNumber) {
        ArrayList<Express> data = new ArrayList<>();
        //1.    获取数据库的连接
        Connection conn = DruidUtil.getConnection();
        PreparedStatement state = null;
        ResultSet result = null;
        //2.    预编译SQL语句
        try {
            if(limit) {
                state = conn.prepareStatement(SQL_FIND_LIMIT);
                //3.    填充参数(可选)
                state.setInt(1,offset);
                state.setInt(2,pageNumber);
            }else {
                state = conn.prepareStatement(SQL_FIND_ALL);
            }

            //4.    执行SQL语句
            result = state.executeQuery();
            //5.    获取执行的结果
            while(result.next()){
                int id = result.getInt("id");
                String number = result.getString("number");
                String username = result.getString("username");
                String userPhone = result.getString("userPhone");
                String company = result.getString("company");
                String code = result.getString("code");
                Timestamp inTime = result.getTimestamp("inTime");
                Timestamp outTime = result.getTimestamp("outTime");
                int status = result.getInt("status");
                String sysPhone = result.getString("sysPhone");
                Express e = new Express(id,number,username,userPhone,company,code,inTime,outTime,status,sysPhone);
                data.add(e);
            }
            //6.    资源的释放
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            DruidUtil.close(conn,state,result);
        }
        return data;
    }

解决方案

  • 首先我们的JDBC可以分为两种方法：增删改方法，查询方法。其中增删改方法返回值都是int，即影响的行数，而查询方法的结果有多种：返回一个int，返回一个对象，返回对象列表List，返回一个Map。所以这是优化的难点。

  • 我们的JDBC核心部分就是SQL，返回值类型和参数了。一个给定的SQL和参数，我们就可以直接在数据库中获取结果了，然后如果我们给定了返回值类型，比如规定返回值类型是一个Student对象，那么可以将结果集封装到这个对象中去。

  • 我们的数据库类型和Java类型是不匹配的，比如varchar和char这些，一般我们认为和String是对应的，所以我们这里也需要进行配置。

方法设计

  1. 对于增删改查方法，就是传入SQL，和参数，由于参数的数量不确定可以使用不定量参数来解决。

    示例：

    • int update(String sql，Object ... objects);

  2. 由于查询方法种类比较多，使用一个方法涵盖万千是比较困难的，我们根据返回值的结果来划分：

    • Map<String,T> queryForMap(String sql，Class<T> className,Object ... objects)
      将结果封装为Map，我们的Map的key是参数名，参数值可以是任何类型，包括对象，所以我们需要传入一个Class对象，用户限定返回值类型，如果我们的查询语句有多种返回结果，那么就是用Object
    • List queryForList(String sql，Class<T> className,Object ... objects)
      将查询结果封装为List，和之前的map方法一样，也要传入一个Class对象
    • Object queryForObject(String sql，Class<T> className,Object ... objects)
      • 将查询结果封装为Object，和之前的map方法一样，也要传入一个Class对象

  3. 我们传入一个Class目的是通过反射机制创建对象和调用方法。这里的对象简单分为两类：POJO和基本数据类型包装类，我们通过一些条件判断来区分，然后使用不用的方式将数据库的查询结果封装进这些对象中。

    • POJO对象

      每一个属性都有对应的get和set方法

    • java.lang包对象

      也就是基本数据类型的包装类，这些对象没有get和set方法，但是我们可以直接构造方法传入对象来实现。

  4. 对于我们数据库查询出来的结果集ResultSet,JDBC提供了丰富的Api，包括查询结果的字段数，各字段的名字，类型等各种结果，我们可以通过这些方法来将数据库查询结果和我们要封装的对象的属性一一对应起来：

    • ResultSetMetaData metaData = resultSet.getMetaData()方法可以获取结果的详细数据。

      我们先得到字段数，然后遍历每一个字段，通过switch()这种暴力的方式将每个字段的类型和Java的数据类型一一对应起来，然后使用get方法来获取结果，然后封装进对象属性中：

      示例：

      • 比如我们要封装为一个String的对象，我们数据库查询结果为字段名为username，值为“dulao”。我们先获取字段的值，比如varchar，然后使用switch一一对应，结果是String.class。然后我们根据swith的结果，调用resultSet的“get”+“S”+"tring"拼接的方式来找到对应的获取String类型的方法，然后使用String对象的newInstance(resultSet.getString(1))的方式来填充我们的Stirng对象
      • 对于POJO对象（Student），在switch之后，我们需要获得字段名username，然后拼接字符串"set"+“U”+"sername"的方式找到setUsername这个方法，然后将查询结果封装进Student的username属性，然后循环遍历下一个属性，最后完成对Student对象每个属性的填充。
      • 我们看到对于基本包装数据类型，处理Integer的有一定的区别以外，其他的都是get加上数据类型首字母大写其他字母小写的方式，然后参数都是int（字段数），这个可以用for循环轻松填充。
      • image-20201003152547641
      • 这是我写的switch，对于现在的项目，只涉及这些类型，其实这个匹配表可单独抽取出一个配置文件，根据不同的需求进行不同配置。
      • image-20201003152829021
      • 还有就是，我们填充POJO对象的时候，都是使用set加上查询结果字段名的首字母大写其他字母小写的方式来实现的，虽然非常有效。但是拓展性比较差，这部分也可以抽取出来，我们的queryForObject方法传参的时候只传入了Class对象，这里可以优化一下，比如我们定义一个接口然后我们自定义实现类来做一一对应关系。
      • image-20201003152931582

参考代码

Jdbc代码优化到一行了！这样我们只要给定SQL，参数，封装的对象类型，就可以返回给我们想要的结果。

image-20201003153540356

参考代码：

看看就好，也可以直接拿来用。

package com.kaikeba.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created with IntelliJ IDEA.
 *
 * @Description :
 * @author: Faker
 * @date : 2020-09-28
 */
public class JdbcUtil {

    /**
     * 自动提交
     */
    private static boolean commit = true;

    /**
     * 自动驼峰命名
     */
    private static boolean camelCase = true;

    /**
     * 设置提交
     *
     * @param commit 提交
     */
    public static void setCommit(boolean commit) {
        JdbcUtil.commit = commit;
    }


    /**
     * 设置自动驼峰命名
     *
     * @param camelCase 自动驼峰命名
     */
    public static void setCamelCase(boolean camelCase) {
        JdbcUtil.camelCase = camelCase;
    }

    /**
     * 获取连接
     *
     * @return {@link Connection}
     */
    private static Connection getConnection() {
        try {
            Connection connection = DruidUtil.getDataSource().getConnection();
            connection.setAutoCommit(commit);
            return connection;
        } catch (SQLException e) {
            throw new RuntimeException("获取连接失败");
        }
    }

    /**
     * 更新
     * 更新方法只要返回影响的行数，返回值都是int
     *
     * @param sql     sql
     * @param objects 对象
     * @return int
     */
    public static int update(String sql, Object... objects) {
        Connection connection = null;
        PreparedStatement statement = null;
        int i = -1;
        try {
            //填充SQL参数
            connection = getConnection();
            statement = connection.prepareStatement(sql);
            int index = 1;
            for (Object object : objects) {
                statement.setObject(index++, object);
            }
            i = statement.executeUpdate();
            return i;
        } catch (SQLException e) {
            e.printStackTrace();
            return i;
        } finally {
            close(connection, statement);
        }
    }

    public static <T> List<Map<String, Object>> queryForMap(String sql, Object... objects) {
        return queryForMap(sql, Object.class, objects);
    }

    /**
     * 将查询结果封装为Map，如果有多条数据则返回一个元素为Map的List集合
     *
     * @param sql       sql
     * @param className 类名
     * @param objects   对象
     * @return {@link T}
     */
    public static <T> List<Map<String, T>> queryForMap(String sql, Class<T> className, Object... objects) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        String methodName = null;
        try {
            connection = getConnection();
            statement = connection.prepareStatement(sql);
            int index = 1;
            //填充SQL参数
            for (Object object : objects) {
                statement.setObject(index++, object);
            }
            resultSet = statement.executeQuery();
            List<Map<String, T>> list = new ArrayList<>();
            //填充查询结果为Java对象
            while (resultSet.next()) {
                Map<String, T> map = handlerMapData(resultSet, className);
                list.add(map);
            }
            return list.isEmpty()?null:list;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            close(connection, statement, resultSet);
        }
    }

    /**
     * 查询为对象
     * 传入一个className，返回与给定类对象类型相同的对象
     * 目前只能处理包装数据类型，POJO类
     *
     * @param sql     sql
     * @param objects 对象
     * @return {@link T}
     */
    public static <T> T queryForObject(String sql, Class<T> className, Object... objects) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = getConnection();
            statement = connection.prepareStatement(sql);
            int index = 1;
            //填充SQL参数
            for (Object object : objects) {
                statement.setObject(index++, object);
            }
            resultSet = statement.executeQuery();
            if (!resultSet.next()) {
                return null;
            }
            return handlerData(resultSet, className);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            close(connection, statement, resultSet);
        }
        //填充查询结果为Java对象

    }

    /**
     * 查询为列表
     * 传入一个className，返回与给定类对象类型相同的对象列表
     *
     * @param sql     sql
     * @param objects 对象
     * @return {@link List<T>}
     */
    public static <T> List<T> queryForList(String sql, Class<T> className, Object... objects) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        String methodName = null;
        try {
            connection = getConnection();
            statement = connection.prepareStatement(sql);
            int index = 1;
            //填充SQL参数
            for (Object object : objects) {
                statement.setObject(index++, object);
            }
        }catch (SQLException e) {
            System.out.println("SQL参数异常!");
            close(connection, statement);
            e.printStackTrace();
            return null;
        }
        try {
            resultSet = statement.executeQuery();
            List<T> list = new ArrayList<>();
            //填充查询结果为Java对象
            while (resultSet.next()) {
                list.add(handlerData(resultSet, className));
            }
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(connection, statement, resultSet);
        }
        return null;
    }


    /**
     * 处理程序数据
     * 这个方法是将结果集封装为对象，可能是封装一个pojo对象，也可能是封装一个Integer普通对象
     * 比如select count(*) from table,也是查询语句，也走ResultSet方法。
     *
     * @param resultSet 结果集
     * @return {@link T}
     */
    private static <T> T handlerData(ResultSet resultSet, Class<T> className) throws SQLException{
        T object = null;
        try {
            //如果是包装数据类型 java.lang下的
            if (className.getName().startsWith("java.lang")) {
                return defaultHandlerData(resultSet, className);
            }
            object = className.newInstance();
            fillInData(object, className, resultSet, false);
        } catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return object;
    }

    private static <T> Map<String, T> handlerMapData(ResultSet resultSet, Class<T> className)throws SQLException {
        Map<String, T> object = null;
        try {
            object = new HashMap<>(16);
            fillInData(object, className, resultSet, true);
        } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return object;
    }

    /**
     * 填充数据
     *
     * @param object    对象
     * @param className 类名
     * @param resultSet 结果集
     * @param toMap     映射
     * @throws SQLException              sqlexception异常
     * @throws NoSuchMethodException     没有这样的方法异常
     * @throws InvocationTargetException 调用目标异常
     * @throws IllegalAccessException    非法访问异常
     */
    private static <T> void fillInData(Object object, Class<T> className, ResultSet resultSet, boolean toMap) throws SQLException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取一条查询记录的字段数
        for (int i = 1; i < metaData.getColumnCount() + 1; i++) {
            //取出每一个字段的名字
            String columnName = metaData.getColumnName(i);
            StringBuffer sb = new StringBuffer();
            Class type = matchObject(metaData.getColumnTypeName(i));
            //格式化
            String baseMethodName=columnName;
            if (camelCase){
                for (int j = 0; j < columnName.length(); j++) {
                    if (columnName.charAt(j) == '_') {
                        j++;
                        sb.append(columnName.substring(j, j + 1).toUpperCase());
                    } else {
                        sb.append(columnName.substring(j, j + 1));
                    }
                }
                baseMethodName=sb.toString();
            }
            //调用对象的set方法来填充对象属性
            String[] strings = type.getTypeName().split("\\.");
            String typeName = strings[strings.length - 1];
            //通过字段名判断使用哪个get方法来查询数据
            String handlerMethodName = "get" + ("Integer".equals(typeName) ? "Int" : typeName.substring(0, 1).toUpperCase() + typeName.substring(1, typeName.length()));
            Method handlerMethod = resultSet.getClass().getDeclaredMethod(handlerMethodName, int.class);
            Object arg = handlerMethod.invoke(resultSet, i);
            //调用get方法
            if (toMap) {
                Method method = object.getClass().getDeclaredMethod("put", Object.class, Object.class);
                method.invoke(object, baseMethodName, arg);
            } else {
                String methodName = "set" + baseMethodName.substring(0, 1).toUpperCase() + baseMethodName.substring(1, baseMethodName.length());
                Method method = className.getDeclaredMethod(methodName, type);
                method.invoke(object, arg);
            }
        }
    }

    /**
     * 默认数据的处理程序
     *
     * @param resultSet 结果集
     * @param className 类名
     * @return {@link T}* @throws NoSuchMethodException 没有这样的方法异常
     * @throws SQLException              sqlexception异常
     * @throws InvocationTargetException 调用目标异常
     * @throws IllegalAccessException    非法访问异常
     * @throws InstantiationException    实例化异常
     */
    private static <T> T defaultHandlerData(ResultSet resultSet, Class<T> className) throws NoSuchMethodException, SQLException, InvocationTargetException, IllegalAccessException, InstantiationException {
        ResultSetMetaData metaData = resultSet.getMetaData();
        Constructor<T> constructor = null;
        Method handlerMethod = null;
        String handlerMethodName = null;
        //匹配该字段的类型，将java.lang分割掉，留下来最后的类型
        Class type = matchObject(metaData.getColumnTypeName(1));
        String[] strings = type.getTypeName().split("\\.");
        String typeName = strings[strings.length - 1];
        //如果是Integer，resultSet的get方法是getInt
        //其他的方法都是类型前加get，一一对应
        if ("Integer".equals(typeName)) {
            constructor = className.getConstructor(int.class);
            handlerMethodName = "getInt";
        } else {
            constructor = className.getConstructor(type);
            handlerMethodName = "get" + typeName.substring(0, 1).toUpperCase() + typeName.substring(1, typeName.length());
        }
        //调用resultSet的get方法得到数据
        handlerMethod = resultSet.getClass().getDeclaredMethod(handlerMethodName, int.class);
        Object arg = handlerMethod.invoke(resultSet, 1);
        //调用一参构造方法
        return constructor.newInstance(arg);
    }


    /**
     * 将数据库的字段的数据类型匹配为我们java的数据类型
     *
     * @param columnTypeName 列类型的名字
     * @return {@link Class<?>}
     */
    private static Class<?> matchObject(String columnTypeName) {
        switch (columnTypeName) {
            case "INT":
            case "BIGINT":
                return Integer.class;
            case "TIMESTAMP":
                return Timestamp.class;
            case "VARCHAR":
            case "CHAR":
                return String.class;
            case "FLOAT":
                return Float.class;
            case "DOUBLE":
            case "DECIMAL":
                return Double.class;
            case "DATE":
            case "DATETIME":
                return Date.class;
            default:
                System.out.println(columnTypeName + "类型没有找到对应的匹配类型");
                return Object.class;
        }
    }


    /**
     * 关闭
     *
     * @param connection 连接
     * @param statement  声明
     */
    private static void close(Connection connection, Statement statement) {
        close(connection, statement, null);
    }

    /**
     * 关闭
     *
     * @param connection 连接
     */
    private static void close(Connection connection) {
        close(connection, null, null);
    }

    /**
     * 关闭
     *
     * @param connection 连接
     * @param statement  声明
     * @param resultSet  结果集
     */
    private static void close(Connection connection, Statement statement, ResultSet resultSet) {
        try {
            if (!commit) {
                connection.rollback();
            }
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


}
程序员小章
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DBCP连接池参数
追求技术的丸子
03-14 1940
DBCP连接池参数说明如下：  1、maxActive="10"：表示并发情况下最大可从连接池中获取的连接数。  2、maxIdle="5"：如果在并发时达到了maxActive=10，那么连接池就必须从数据库中获取10个连接来供应用程序使用，当应用程序关闭连接后，由于maxIdle=5,因此并不是所有的连接都会归还给数据库，将会有5个连接保持在连接池种中，状态为空闲。由于我们没有使用minE
乐字节十个项目课，这应该是市面上最值得推荐的 Java 练手项目！！！
weixin_46483398的博客
08-04 2571
1.JavaEE初级项目-乐字节云R记 项目简介 云R记软件就是用于记录日常生活点滴。一款跨平台的简单快速的个人记事备忘工具，并且能够实现PC、移动设备和云端之间的信息同步，简洁高效。将会议记录、日程安排、生活备忘，奇思妙想、快乐趣事以及任何突发灵感都可快速记录到系统中。 本系统采用 B/S 架构，使用 BootStrap + Jsp + Servlet + MySQL+ Tomcat 开发，使用 Maven 构建，采用 Junit 单元测试、Log4j 搭建日志、使用 POI 导入导出报表，操作 DB
Java【有哪些适合新手练手的Java项目？】
热门推荐
阿俊的博客
09-10 2万+
Java作为一门古老的语言，已有20年左右的历史，这在发展日新月异的技术圈可以说是一个神话。 虽然不少人曾抱怨Java语言就像老太太的裹脚布，又臭又长，有时写了500行都不能表达程序员的意图。 但从市场上的招聘现状看，Java工程师依然有着其他语言不可取代的竞争优势。 看到了这里，恭喜正式开始进入主题：适合新手练手的Java项目？  C9154343-0F98-4774-A
Java编写快递e栈
jinghongwu123的博客
02-06 397
前言 本人萌新刚用csdn不好之处，多多包涵！！！！！ 本人萌新刚用csdn不好之处，多多包涵！！！！！ Java实现快递e栈 切换用户界面 快递信息的保存 各个子功能的实现 今天的任务，是完成快递 E 栈系统。 经过了变量，流程控制，数组三部分的学习，让我们通过一个小项目来巩固这些技能点吧 一、java中equals使用方法 equals: 操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同,且区分大小写 二、使用步骤 1.创建数组 代码如下（示例）： String[] ordersId
快递管理控制台项目，加深对基础知识的理解
wth33的博客
10-05 292
有关异常机制的总结，同时通过编写快递管理控制台项目加深对异常以及数组等知识点的理解。 首先复习一下异常机制。 java中的异常分为两大类： 受检异常(异常会显示红色)和非受检异常（异常不会显示红色） 常用的异常是try…catch…finally以及throws 1、关于try…catch…fnally的知识汇总（面试常问） 语法为： try{ 有可能发生异常的代码段 }catch(异常类型 对象名){ 异常的处理操作 }finally{ 必然执行的异常的统一的出口 } 无论是否发生异常，finally必然
快递e栈(控制台简易版)——最最最基础
How many ten years in the life time?
07-24 386
快递E栈(控制台简易版)—最最最最基础 考察内容：变量+流程控制+数组 项目实现： 角色切换(快递员和普通用户) 快递员功能:存快递，删除快递，修改快递，查看所有快递 普通用户功能:取快递 存快递 删除快递 修改快递 查看所有快递 取快递 任务过程： 切换用户界面 快递信息的保存 各个子功能的实现 判断用户输入的数字是否正确 利用的switch中的default，如果输入不正确，则递归再执行一遍本方法。 代码如下： import java.util.Random;
快递e栈集合实现
weixin_45685952的博客
04-05 530
快递e栈（集合篇） 文章目录快递e栈（集合篇）MVC模式（三层架构模式）题目：代码实现：1、cn.suzihan.java.courierCabinet.view包2、cn.suzihan.java.courierCabinet.bean包3、cn.suzihan.java.courierCabinet.dao包4、cn.suzihan.java.courierCabinet.main包Main类Courier类User类题中遇到的问题：1.用户如何取件？ MVC模式（三层架构模式） 概念： ​ MVC（
JavaEE项目实战（OA系统）之四_三大框架整合之一
hanhf的专栏
09-09 8129
Java项目的包组织结构
JavaEE完全实战详解笔记--在Eclipse中创建一个简单的web项目
西召
04-27 1万+
下面演示了Eclipse开发JavaEE的通用步骤--配置一个简单的web应用，不同版本的Eclipse可能略有不同，但是基本不会有太大出入。              这里就以"eclipse-jee-luna-SR2-win32"+“apache-tomcat-8.0.21-windows-x86”版本为例，（截止2015年5月份的最新版）：             （详细过程看图）
java中利用反射机制实现调用给定为字符串的方法名
z69183787的专栏
10-27 2965
1、被测试类 package demo.reflect; /**  * 被测试类  * @author wangyanjun  *  */ public class Quizzee {  public void testMethod(String arg1,Integer arg2){   System.out.println("测试结果：反射方法的调用");   Sy
JavaEE项目实战（OA系统）之七_部门管理之一
hanhf的专栏
09-10 3805
OA系统之部门管理之一_实体类
Java-使用集合存储快递的信息
彭_德华的博客
09-12 1384
还记得之前的快递管理吗？学习了集合以后，使用集合来进行快递信息的存储吧。 一共分为四个部分： 快递信息部分(Express) 管理员部分(快递员)(Courier) 用户部分(Customer)。 调用部分(Main) 第一部分是快递信息(Express) 包含了变量的建立，快递单号expressId,快递单公司company，快递柜子号数boxNum，取件码codes。以及它们的getter/setter方法、toString方法。 /** * 快递信息部分 */ import java.
推荐一款JavaEE项目原型设计工具
开心阳
09-11 3559
最近发现一款非常犀利的项目原型设计工具，特别是对于后台的原型设计更加给力！ 软件名称：Mockups 下载地址：http://download.csdn.net/detail/shakespeare001/4563363 安装后进行如下设置方可输入中文：点击View——>勾选Use System Fonts 软件截图：
反射工具类：释放资源、获取对对象属性、设置属性等
weixin_30352645的博客
10-17 126
反射工具类：释放资源、获取对对象属性、设置属性等 package cn.elwy.common.util; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.Map; import org.apache.commons.beanutils.BeanUtils; impor...
java 项目练习题
AntKengElephant的博客
10-31 4437
这里一共有51道JAVA基础练习题，代码中有题目，太懒了我就不一个个打目录了，是将别人的代码一个个粘了过来，感谢作者 输出9*9口诀 /** * * * */ public class Test { public static void main(String[] args) { for (int i = 1; i &lt; 10; i++) { for (i...
实验1 JavaEE开发环境配置与基础练习（JSP）
lmm0513的博客
02-28 4275
实验1 JavaEE开发环境配置与基础练习（即：JSP） 实验项目目的和任务： 本实验，目的是熟悉JDK、Tomcat、MyEclipse的安装与配置，为后续的实验作好准备工作。要求熟悉JSP环境搭建特别是环境变量的配置以及如何配置好Tomcat服务器；学会建立第一个JSP页面，其中要注意JDK的配置，实现简单输出。 实验内容： 一、JDK的安装与配置 https://mp.cs...
JAVAEE项目实践 ： 一、javaee技术总结（可以使用的功能）
无知的贤者博客
01-23 3168
一：JDBC：提供对各种关系数据库的统一接口。 二：JavaBeans：符合某种特定规范的Java类。 （我的理解：JavaBeans就是以特定格式进行书写的类，主要是为了提高类的可服用性。该特定格式是指对公有类的私有属性进行get、set的方法设置与无参构造方法的设置。如下图） 而且JavaBeans格式的类可以在JSP文件中被引用，从而达到控制活动的作用。 关于JavaBeans的具体情况这...
快递e栈（集合篇）---文件数据存储
weixin_43696580的博客
12-07 226
之前写的快递e栈，将快递数据由集合存储，现在稍微补充一点，将文件存储到一个文件中，可以详细看到。 public void fileOutputStream(Express express) throws FileNotFoundException { FileOutputStream fos = new FileOutputStream("E://b.txt",true); PrintStream ps = new PrintStream(fos); St
根据反射执行某一个类的方法
daiky_transition的博客
03-10 2977
// 根据类名和方法名执行方法 beanClass：全路径 methodName：方法名，要执行的方法 @SuppressWarnings({ "unchecked", "rawtypes" }) public static void executeMethod(String beanClass, String methodName) { try { Class clz =...
JavaEE期末复习笔记
I am Grooter...
07-05 8480
Struts 2 第四章 自定义标签具有如下优势： 开发更简单 可维护性强 复用性高 自定义标签可分为3类： 非UI标签：数据访问，逻辑控制 流程控制标签 数据访问标签 UI标签：生成HTML元素 表单标签 非表单标签 Ajax标签：支持Ajax 值栈中存在的对象：模型对象，action对象，request对象 OGNL的跟对象为值栈 值栈对应ValueStack接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值