精华内容
下载资源
问答
  • 容器是指对对象的容纳,java中主要有这几个容器:list(列表)、set(集合)、map(映射)。所有容器都无法保存基本数据类型,需要先把基本数据类型变为封装类,用容器保存封装结果。一.List(列表)1.ArrayList,线性表,...

    容器是指对对象的容纳,java中主要有这几个容器:list(列表)、set(集合)、map(映射)。所有容器都无法保存基本数据类型,需要先把基本数据类型变为封装类,用容器保存封装结果。

    一.List(列表)

    1.ArrayList,线性表,容量大小可变的数组  <===>tArrayLisk()

    2.LinkedList,链表,没有使用顺序存储机制,无法根据索引快速存取  <===>tLinkedList()

    3.迭代器遍历LIst  <===>demo2()

    1 public static voidtArrayList(){2 /*

    3 ArrayList的构造方法:4 ArrayList a1=new ArrayList(); //构造一个空的线性表5 ArrayList a1=new ArrayList(b); //根据已有类集构造线性表6 ArrayList a1=new ArrayList(20); //构造指定初始容量的线性表7 */

    8 ArrayList a1=newArrayList();9 a1.add("a");10 a1.add("z");11 a1.add("x"); //add(value),插入元素

    12 a1.remove(0); //remove(index),根据数组索引删除元素

    13 a1.set(0,"z1"); //set(index,value),重设指定索引处的值

    14 System.out.println(a1.indexOf("z1")); //indexOf(value),获取指定元素的索引

    15 a1.add("z1");16 System.out.println(a1.lastIndexOf("z1")); //latIndexOf()value,获取指定元素最后一次出现的位置17 //subList(),获取列表的子列表,需要给出起止位置 listIterator(),生成一个列表迭代器,此迭代器功能强大

    18

    19 for(int i=0;i

    20 System.out.print(a1.get(i)+",");21 }22

    23 }24 public static voidtLinkedList(){25 LinkedList l=newLinkedList();26 l.addFirst(1); //addFirest(),向链表头添加元素

    27 l.addLast(10); //addLast(),向链表尾添加元素

    28 l.removeLast(); //removeLast(),移除链表尾部元素

    29 System.out.println(l.getFirst()); //getFirst(),获取链表头元素

    30 }31 public static voiddemo2(){32 //使用迭代器遍历List

    33 List l1=new ArrayList();34 l1.add("a1");35 l1.add("a2");36 l1.add("a3");37 for(Iterator it=l1.iterator();it.hasNext();){ //使用hasNext()判断序列中是否还有元素

    38 String s=it.next(); //使用Next()获取序列中下一个元素

    39 System.out.println(s);40 }41 }

    二.Set(集合)

    Set和List的区别:Set没有顺序,不允许保存相同值的元素。

    1.Iterator,迭代器,单向移动,实现遍历  <===>demo1()

    2.for-each遍历  <===>demo2()

    3.HashSet散列集,避免Set的元素重复  <===>demo3()

    4.TreeSet,实现红黑树数据结构后的set

    5.比较HashSet、TressSet、LinkedHashSet的区别  <===>demo4()

    public static voiddemo1(){

    Set s1=new HashSet();

    s1.add("a1");

    s1.add("a2");

    s1.add("a3");for(Iterator it=s1.iterator();it.hasNext();){

    String s=it.next();

    System.out.println(s);

    }

    }public static voiddemo2(){

    Set s1=new HashSet();

    s1.add("a1");

    s1.add("a2");

    s1.add("a3");for(String s:s1){ //for-each遍历set,将每一次的值存在s中

    System.out.println(s);

    }

    }public static voiddemo3(){

    Set s1=new HashSet(); //new一个HashSet,通过下边的for循环为该set填充值

    for(int i=1;i<100;i++){

    Integer temp=new Integer(i%6);

    s1.add(temp);

    }for(Iterator it=s1.iterator();it.hasNext();){ //通过Iterator遍历set

    System.out.println(it.next());

    }

    }public static voiddemo4(){//比较HashSet、TreeSet、LinkedHashSet的区别

    Set s1=new HashSet();

    Set s2=new TreeSet();

    Set s3=new LinkedHashSet();for(int i=0;i<5;i++){int s=(int)(Math.random()*100);

    Integer temp=newInteger(s);

    s1.add(temp);

    s2.add(temp);

    s3.add(temp);

    System.out.println("第"+i+"次产生的随机数为:"+s);

    }

    System.out.println("HashSet:"+s1); //元素存放顺序和添加时的顺序无关

    System.out.println("TreeSet:"+s2); //对set中的元素按照值进行排序存放

    System.out.println("LinkedHashSet:"+s3); //元素存放顺序按照添加时的顺序

    }

    三.Map(映射)

    Map维护键值对,一个Map中不能有重复的键,每个键只能映射一个值,键与值都视为对象,Map允许null值,基于哈希表的Map接口实现,哈希表的作用是保证键的唯一性。

    1.Map遍历的三种方法

    1 public static void byValue(Mapmap){2 String value=null;3 Iterator it= map.values().iterator(); //通过HashMap.values()得到“值”的集合,再去遍历值的集合

    4 while(it.hasNext()){5 value=(String)it.next();6 System.out.println(value);7 }8 }9 public static void byKey(Mapmap){10 String key=null;11 String value=null;12 Iterator it=map.keySet().iterator(); //通过map.KeySet()得到key的集合

    13 while(it.hasNext()){14 key=(String)it.next();15 value=(String)map.get(key);16 System.out.println("key:"+key+",value:"+value);17 }18 }19 public static void byEntry(Mapmap){20 String key=null;21 String value=null;22 Iterator it=map.entrySet().iterator(); //通过entrySet()实现

    23 while(it.hasNext()){24 Map.Entry entry=(Map.Entry) it.next();25 key=(String)entry.getKey();26 value=(String)entry.getValue();27 System.out.println("key:"+key+",value:"+value);28 }29 }

    2.HashMap散列映射

    3.其他Map

    展开全文
  • 首先,它使Python 程序员介入到Java 开发环境并让他们能快速开发方案原型,以便无缝地集成到现有的Java 平台上。其次,它能在Java 中加入脚本语言,并以此来简化数计百万计的Java 程序员的工作。Java 程序员们,再也...

    概述:

    Jython 是一种可以把两种不同的编程语言结合在一起的工具。首先,它使Python 程序员介入到Java 开发环境并让他们能快速开发方案原型,以便无缝地集成到现有的Java 平台上。其次,它能在Java 中加入脚本语言,并以此来简化数计百万计的Java 程序员的工作。Java 程序员们,再也不用为他们刚写的一个类写一大堆的测试用例或驱动程序。Jython

    提供了Python 的大部分功能,以及实例化Java 类并与Java 类交互的功能。Jython 代码被动态地编译成Java 字节码,因此,你可以用Jython 扩展Java 类。也可以用Java 来扩展Python。在Python 中写一个类,像使用Java 类一样使用这个类是很容易的事情。你甚至可以把Jython 脚本静态地编译为Java 字节码。

    ——《Python核心编程》

    本人环境:

    系统:CentOS release 6.5 (Final)

    JDK:java version "1.7.0_75"

    Python:Python 2.6.6

    Jython:2.7-b1

    安装:

    jython安装包地址(jython-installer-2.7-b1.jar):

    http://download.csdn.net/detail/u013761665/8590143

    安装步骤:

    1.切换工作目录到下载的jython-installer-2.7-b1.jar所在目录下(当然,如果你使用一些相对或是绝对路径也是可以的);

    2.使用java -jar jython-installer-2.7-b1.jar命令进行安装(此步操作的前提是你的系统中已经成功安装了jdk);

    3.进入jython安装目录,输入./jython。注意,这里不能使用jython,除非你有配置你的PATH

    java代码编写:

    package com.w.shell.jar.main;

    public class Main {

    public Main() {

    System.out.println("Hello, Welcome this shell.");

    }

    /**

    * @author Q-WHai

    * 2015-4-13

    */

    public static void main(String[] args) {

    new Main();

    }

    public static void printLog() {

    System.out.println("This is a shell log show 2 you. And you will get nothing whit this function return.");

    }

    public static String getLog() {

    String toReturn = "Custom log";

    System.out.println("This is another shell log show 2 you. And you will get a return String.");

    return toReturn;

    }

    }

    jar包制作:

    通过上面的Java代码操作jar.不过这里不再对jar包的操作进行过多地叙述,因为在本人早期的博客有详细地说明(在cmd中使用指令来执行jar包).

    jython代码编写:

    而对于jython的代码则十分简单,如下:

    import sys

    sys.path += ["/root/study/coding/java/shell.jar"]

    from com.w.shell.jar.main import Main

    Main.printLog()

    result = Main.getLog()

    print result

    运行示例:

    1.将工作目录切换至jython的安装目录下(当然,如果你使用一些相对或是绝对路径也是可以的);

    2.运行../../splace/jython/jython jython_test.py(即:your_jython_path your_jython.py)

    3.运行效果:

    Center

    展开全文
  • MyBatis是一个优秀的持久层框架,它对JDBC操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等JDBC繁杂的...

    MyBatis是一个优秀的持久层框架,它对JDBC操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等JDBC繁杂的过程代码。

    对JDBC进行封装的框架有哪些

    Mybatis,Hibernate,dbutils,Spring中的jdbcTemplate。

    MyBatis基本原理

    Mybatis通过xml或注解的方式将要执行的各种statement(statement、preparedStatemnt、CallableStatement)配置起来,并通过java对象和statement中的sql进行映射生成最终执行的sql语句,最后由Mybatis框架执行sql并将结果映射成java对象并返回。

    使用JDBC操作数据库存在的问题

    数据库连接频繁开启和关闭,会严重影响数据库的性能。代码中存在硬编码,分别是数据库部分的硬编码和SQL执行部分的硬编码。

    一、准备工作

    我们先要下载MyBatis + Mysql驱动包

    Mybaits下载:传送门~

    Mysql驱动下载:传送门~

    准备项目:

    打开IDEA,新建一个简单的Java项目,项目就叫Mybaits吧,在项目Mybaits目录下创建一个libs目录(用于存放项目所要依赖的jar包),那要放哪些jar包呢?

    需要的jar包有这些:

    72d0307f155f2093570b9be7d6c2eeee.png

    把jar包拷贝到libs目录下,别忘了libs → 右键 → Add as Library(这才是真正导入jar包)

    目录结构:

    d633acc6326b8e5a016438fd1fbf78ca.png

    准备数据库:

    Mysql数据库,数据库名sys,表名Student(可以使用开发工具Navicat来创建数据库)

    Student表:

    13dd62b6fb64703474d43988a6f46d24.png

    二、 MyBatis快速入门

    主要步骤:

    1、 创建PO(model)类(根据需求创建)

    2、 创建全局配置文件SqlMapConfig.xml(文件名任意)

    3、 编写映射文件

    4、 加载映射文件,在全局配置文件SqlMapConfig.xml中进行加载

    5、 编写一个测试程序,即编写Java代码,连接并操作数据库

    编写测试程序的步骤:

    a) 读取配置文件。

    b) 通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。

    c) 通过SqlSessionFactory创建SqlSession。

    d) 调用SqlSession的操作数据库方法。

    e) 关闭SqlSession。

    注意: Mybatis使用的日志包是log4j的,所以需要添加log4j.properties(文件内容可以从mybatis-3.5.5.pdf中拷贝,mybatis-3.5.5.pdf就在下载后的Mybatis的目录里)

    最终的目录结构:

    4c2c3f9dcc6a3005e4d6c8e5b5dc76e8.png

    全局配置文件SqlMapConfig.xml中的代码:

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd"> 
    <configuration>
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/sys"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456789"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper resource="cn/kkdy/map/StudentMap.xml"/>
        </mappers>
    </configuration>

    全局配置文件简单说明:

    dataSource标签里有4个property,分别表示注册驱动、数据库连接的路径、用户名、密码。mappers标签的子标签mapper用于加载映射文件StudentMap.xml。

    映射文件StudentMap.xml中的代码:

    <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.kkdy">
        <select id="StudentById" parameterType="String" resultType="cn.kkdy.model.Student">
            select * from Student where id = #{id}
        </select>
    </mapper>

    映射文件简单说明:

    命名空间(namespace)用于区分不同的mapper,select标签中的id,通过id可以知道要执行的是哪一个sql语句,parameterType用于表示传进来的参数类型,即#{id}中的参数id的类型,resultType指返回的结果类型。

    log4j.properties中的代码:

    # Global logging configuration
    log4j.rootLogger=ERROR, stdout
    # MyBatis logging configuration...
    log4j.logger.org.mybatis.example.BlogMapper=TRACE
    # Console output...
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

    提示: 以上三个配置文件的代码都可以从文件mybatis-3.5.5.pdf中找到(这个文件就在下载后的Mybatis的目录里),我们只需要拷贝过来修改即可。

    Student类(model):

    package cn.kkdy.model;
    
    public class Student {
    
        private String id;
        private String name;
        private int age;
        private String sex;
        private int score;
    
        public Student() {
        }
    
        public Student(String id, String name, int age, String sex, int score) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.score = score;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public int getScore() {
            return score;
        }
    
        public void setScore(int score) {
            this.score = score;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "id='" + id + ''' +
                    ", name='" + name + ''' +
                    ", age=" + age +
                    ", sex='" + sex + ''' +
                    ", score=" + score +
                    '}';
        }
    }

    TestStu类(测试类):

    package cn.kkdy.test;
    
    import cn.kkdy.model.Student;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    public class TestStu {
    
        @Test
        public void test() throws IOException {
    
            //1、读取配置文件
            String resource = "SqlMapConfig.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
    
            //2、通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂
            SqlSessionFactory sqlSession = new SqlSessionFactoryBuilder().build(inputStream);
    
            //3、通过SqlSessionFactory创建SqlSession
            SqlSession session = sqlSession.openSession();
    
            //4、调用SqlSession的操作数据库方法
            Student s = session.selectOne("mybatis.kkdy.StudentById", "202004");
    
            System.out.println(s);
            session.commit();
            session.close(); //关闭SqlSession对象
        }
    }

    运行结果:

    Student{id='202004', name='酷酷的猿', age=20, sex='男', score=100}

    代码分析:

    重点讲解selectOne("mybatis.kkdy.StudentById", "202004")方法中的参数。

    第一个参数,mybatis.kkdy就是映射文件中mapper标签中命名空间(namespace)的值,StudentById指的是映射文件中select标签中id的值,总的来说,这个参数就是相当于一个sql语句。

    第二个参数,这个参数的值会传递给映射文件中的sql语句中的变量id。

    特别说明:

    本文仅演示了查询数据库记录,其他数据库操作例如增、删、改都是类似的,只不过是调用了不同的方法而已。

    如果要对数据库进行多种操作,可能会出现重复的代码,我们可以通过创建新的方法,并使用注解@Bufore、@After来抽取重复代码。

    最后,我为了演示方便,都是直接抛出异常(不建议这样),建议处理异常。

    三、总结

    MyBatis快速入门,就是这么简单。如果觉得还不错的话,就送我一个赞同吧!如果本文对你有用的话,也欢迎收藏哦!

    展开全文
  • Java反射封装公有DAO

    2019-09-02 21:32:03
    有利便有弊,坏处就是依赖框架,忘记了Java基础,不在关注底层是怎么实现的,这里大家一起回顾一下最原始的jdbc写法: 第一步:导入jar包,这里不多说了,随便百度下都有; 第二步:创建BaseDao(偷下懒,把所有方法...

    现在都是用框架去开发,既简单又快速,给我们提供了很多便利;有利便有弊,坏处就是依赖框架,忘记了Java基础,不在关注底层是怎么实现的,这里大家一起回顾一下最原始的jdbc写法:

    第一步:导入jar包,这里不多说了,百度都有;

    第二步:创建BaseDao(偷下懒,把所有方法都写在一个类里面了),上代码:

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 公共dao类
     */
    @Component
    public class BaseDao<T> {
    
        private final Logger logger = LoggerFactory.getLogger(BaseDao.class);
        private Connection conn = null;
        private PreparedStatement ps = null;
        private ResultSet rs = null;
    
    
        /**
         * 建立数据库连接
         * @return
         */
        private Connection getConnection() {
            try {
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
    
                if (!conn.isClosed()) {
                    logger.info("################# 数据库连接成功 #################");
                }
            } catch (ClassNotFoundException e) {
                logger.error("加载jdbc.Driver异常", e);
                throw new RuntimeException("加载jdbc.Driver异常", e);
            } catch (SQLException e) {
                logger.error("建立数据库连接异常", e);
                throw new RuntimeException("建立数据库连接异常", e);
            }
            return conn;
        }
    
        /**
         * 方法用途: 公共查询方法,返回List集合<br/>
         * 操作步骤: TODO<br/>
         * ${tags}
         */
        public <T> List<?> queryList(Class<T> clazz, String sql, Object... params) {
            T t;
            List<T> list = new ArrayList<>();
            logger.info(sql);
            logger.info(null == params? "" : params.toString());
    
            try {
                Field[] fields = getAllFields(clazz);
                conn = getConnection();
                ps = conn.prepareStatement(sql);
                initParams(ps, params);
                rs = ps.executeQuery();
                // 返回结果集
                while (rs.next()) {
                    t = getObjResult(fields, rs, clazz);
                    list.add(t);
                }
                logger.info(String.format("################# 查询成功,共%s条记录 #################", list.size()));
            } catch (SQLException e) {
                logger.error("执行查询异常", e);
                throw new RuntimeException("执行查询异常", e);
            } finally {
                // 关闭数据库连接
                closeDb(rs, ps, conn);
            }
            return list;
        }
    
        /**
         * 将每行结果存入map集合,对象属性名为key,查询出的结果为value
         * @param fields
         * @param rs
         * @return
         */
        private <T> T getObjResult(Field[] fields, ResultSet rs, Class<T> clazz) {
            T t = null;
            Field field;
            Method method;
            String fieldName;
            String fieldType;
    
            try {
                t = clazz.newInstance();
                for (int i = 0; i < fields.length; i++) {
                    field = fields[i];
                    field.setAccessible(true);
                    fieldName = field.getName();
                    if (fieldName.equals("serialVersionUID")) {
                        continue;
                    }
                    fieldType = field.getType().getName();
                    method = getMethod(clazz, field, fieldName, fieldType);
                    Object value = rs.getObject(initField(fieldName));
                    if (fieldType.equals("java.lang.String")) {
                        method.invoke(t, value);
                    } else if (fieldType.equals("java.lang.Integer")) {
                        method.invoke(t, Integer.valueOf(value.toString()));
                    }
                }
            } catch (SQLException e) {
                logger.error("rs获取结果异常", e);
                throw new RuntimeException("rs获取结果异常", e);
            } catch (InvocationTargetException e) {
                logger.error("method.invoke方法执行异常", e);
                throw new RuntimeException("method.invoke方法执行异常", e);
            } catch (IllegalAccessException e) {
                logger.error("method.invoke方法执行异常", e);
                throw new RuntimeException("method.invoke方法执行异常", e);
            } catch (InstantiationException e) {
                logger.error("建立T对象异常", e);
                throw new RuntimeException("建立T对象异常", e);
            }
            return t;
        }
    
        /**
         * 对象属性的set方法
         * @param clazz
         * @param field
         * @param fieldName
         * @param fieldType
         * @return
         */
        private Method getMethod(Class clazz, Field field, String fieldName, String fieldType){
            Method method = null;
            try {
                if (fieldType.equals("java.lang.Boolean")) {
                    method = clazz.getDeclaredMethod("is" + getMethodName(fieldName), field.getType());
                } else {
                    method = clazz.getDeclaredMethod("set" + getMethodName(fieldName), field.getType());
                }
            } catch (NoSuchMethodException e) {
                Class superClazz = clazz.getSuperclass();
                method = getMethod(superClazz, field, fieldName, fieldType);
            }
            return method;
        }
    
        /**
         * 获取所有属性(getSuperclass:获取父类属性)
         * @param clazz
         * @param <T>
         * @return
         */
        private <T> Field[] getAllFields(Class<T> clazz) {
            Class superClazz = clazz;
            List<Field> fieldList = new ArrayList<>();
            while (null != superClazz) {
                fieldList.addAll(new ArrayList<>(Arrays.asList(superClazz.getDeclaredFields())));
                superClazz = superClazz.getSuperclass();
            }
            Field[] fields = new Field[fieldList.size()];
            fieldList.toArray(fields);
            return fields;
        }
    
        /**
         * 将驼峰属性名转换为带下划线字段(xx_xx)
         * @param field
         * @return
         */
        private String initField(String field) {
            StringBuilder newField = new StringBuilder();
            for (int i = 0; i < field.length(); i++) {
                char c = field.charAt(i);
                if (Character.isUpperCase(c)) {
                    newField.append("_").append(Character.toLowerCase(c));
                } else {
                    newField.append(c);
                }
            }
            return newField.toString();
        }
    
        /**
         * 组装参数
         * @param ps
         * @param params
         */
        private void initParams(PreparedStatement ps, Object... params) {
            if (null != params && params.length > 0) {
                try {
                    for (int i = 0; i < params.length; i++) {
                        ps.setString(i, params[i].toString());
                    }
                } catch (SQLException e) {
                    logger.error("ps设置参数异常", e);
                    throw new RuntimeException("ps设置参数异常", e);
                }
            }
        }
    
        /**
         * 方法用途: 把一个字符串的第一个字母大写、效率是最高的<br/>
         * 操作步骤: TODO<br/>
         * ${tags}
         */
        private static String getMethodName(String fildeName) {
            byte[] items = fildeName.getBytes();
            items[0] = (byte) ((char) items[0] - 'a' + 'A');
            return new String(items);
        }
    
        /**
         * 关闭数据库连接
         * @param rs
         * @param ps
         * @param conn
         */
        private void closeDb(ResultSet rs, PreparedStatement ps, Connection conn) {
            try {
                if (null != rs) {
                    rs.close();
                }
    
                if (null != ps) {
                    ps.close();
                }
    
                if (null != conn) {
                    conn.close();
                }
    
                logger.info("################# 连接关闭成功 #################");
            } catch (SQLException e) {
                logger.error("关闭连接异常", e);
                throw new RuntimeException("关闭连接异常", e);
            }
        }
    }
    
    

    好了,都是我手敲出来的代码,注释也都加上了,不懂的多读几遍代码吧,实在看不明白先回顾下Java反射的基础(Java反射基础案例

    展开全文
  • 为了能够实现快速就业、同时也是出于对高薪的追求,很多人选择转行学习Java编程开发。学习Java前途怎么样?JavaWeb面试宝典有哪些?下面一起来看看吧。 1.session和cookie的区别? session是存储在服务器端,cookie...
  • 介绍通过本项目能够更直观地理解应用层和运输层网络协议, 以及继承封装多态的运用. 网络部分是本文叙述的重点, 你将看到如何使用Java建立TCP和UDP连接并交换报文, 你还将看到如何自己定义一个简单的应用层协议来让...
  • EasyExcel是阿里出品的一款基于Java语言的Excel文件读写工具,使用简单,节省内存。它基于Apache Poi框架实现,解决了Poi耗内存大的问题,并且避免了大部分内存溢出情况。EasyExcel封装了许多模型转换的操作,使用...
  • 实际上在,做web开发,比较少遇到使用一些算法之类的,毕竟不是做搜索引擎,也不是写底层(比如写个类似于mysql这样的数据库,里面需要自己实现排序算法),另外,每种语言,比如java,php都或多或少已经封装好排序...
  • JAVA设计模式有感

    2014-08-03 21:18:34
    记得在大学学JAVA那阵,就觉得JAVA是一个c语言的一个包装,各种封装好的类库、功能,学习JAVA快速上手编码。时隔8年,我感觉自己不懂JAVA。  最近看了有1个月的设计模式了,进度比较缓慢,一共才看了4个"策略...
  • TsFrame抽象类 封装了脚本的逻辑流程(帮助你快速开发脚本)Fa和Fb 都是继承自F,他们大部分方法都是一样的。重新封装了屏幕点击和模糊找色的方法给TsFrame.继承关系:ScreenLib → F → Fa(Fb同此)怎么创建一个游戏...
  • C#对java的很多语法都进行了修补,但变化其实不算很大 属性 ...如此如此就封装完两个变量name和age了,感觉也没怎么简单,反而觉得idea的快捷封装更简单点,说一句prop+tab可以快速封装 class Program
  • TsFrame抽象类 封装了脚本的逻辑流程(帮助你快速开发脚本)Fa和Fb 都是继承自F,他们大部分方法都是一样的。重新封装了屏幕点击和模糊找色的方法给TsFrame.继承关系:ScreenLib → F → Fa(Fb同此)怎么创建一个游戏...
  • 5.5 小结:方便快速的数组 129 5.6 习题 129 第2篇 Java语言高级语法 第6章 Java的类(Class)和对象(Object) 132 教学视频:59分钟 6.1 驾驶汽车向类(Class)的世界进发 132 6.1.1 汽车带来的问题 132 ...
  • 也谈新郎、sohu新闻系统的技术,当然是怎么用jsp实现的 一份 tomcat vs resin 的测试报告 一个 Java,各自表述 一个applet---servlet通讯的例子 一个JDBC-ODBC桥的字符集参数的例子 一个进行Base64编码的类 ...
  • java 面试题 总结

    2009-09-16 08:45:34
    Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。 原始类型封装类 booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble ...
  • 5.5 小结:方便快速的数组 129 5.6 习题 129 第2篇 Java语言高级语法 第6章 Java的类(Class)和对象(Object) 132 教学视频:59分钟 6.1 驾驶汽车向类(Class)的世界进发 132 6.1.1 汽车带来的问题 132 ...
  • 5.5 小结:方便快速的数组 129 5.6 习题 129 第2篇 Java语言高级语法 第6章 Java的类(Class)和对象(Object) 132 教学视频:59分钟 6.1 驾驶汽车向类(Class)的世界进发 132 6.1.1 汽车带来的问题 132 ...
  • 常用设计模式及 Java程序设计 第一章设计模式基础 一:什么是设计模式 在面向对象的软件设计中,总是希望避免重复设计或尽可能少做重复设计。有经验的面向对象 设计者的确能做出良好的设计,而新手则面对众多选择...
  • 个人有感java和微软

    千次阅读 2005-06-05 12:24:00
    直接把java的一套往.net上面搬,搬完了才发现不是那么回事情。微软的东西都是这样,看不到代码,很多东西直接封装掉。想改,没有那么简单,它设计的时候,好像首要考虑的是快速开发的能力。首先考虑的是怎么能够让人...
  • 框架是一个半成品,对于Java语言来说,框架就是封装了别人的代码。在框架的基础上我们在进一步开发,虽是一种拿来主义,但开发效率较高。 1.2 框架解决什么问题 解决的是技术整合问题。软件开
  • Mybatis快速入门(一)

    2020-06-19 00:21:27
    框架是一个半成品,对于Java语言来说,框架就是封装了别人的代码。在框架的基础上我们在进一步开发,拿来主义。 框架解决什么问题 解决的是技术整合问题。软件开发环境和规模都很大,不可能任何一个项目的代码都从零...
  • 一、面向对象简介考虑现实...面向对象:将数据与函数绑定到一起,进行封装,这样能够更快速的开发程序,减少了重复代码的重写过程。面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程的思...
  • 封装 13 多态性 13 【基础】java多态的理解 13 【基础】transient关键字 15 【基础】访问修饰符区别 15 【基础】java基本数据类型(四类八种) 15 Java自动类型转换 16 数据类型自动提升(注意以下讨论的是二元操作...
  • JeeSite是基于多个优秀的开源项目,高度整合封装而成的高效,高性能,强安全性的开源Java EE快速开发平台。JeeSite是您快速完成项目的最佳基础平台解决方案,JeeSite是您想学习Java平台的最佳学习案例,J...
  • 在说之前首先要明白组件是什么意思,组件其实就是封装成通用的模块,可以进行复用,就像java封装的工具类等; vue的组件就是扩展HTML元素,封装可重用的代码(就是通用的模块); 那么我们知道vue组件的意义之后怎么...
  • 用于帮助使用者快速开发高性能协议服务器。 为什么要用netty? 首先是Java原生的NIO接口并不是那么好用,没有经验的程序员也很难使用远程NIO构建出高性能的协议服务器。而且还有著名的selector空轮询bug。 netty对...
  • 猫眼电影

    千次阅读 2019-03-14 21:04:55
    集群内节点状态快速感知 项目中使用redis做了什么 使用redis存储用户登录信息 使用redis的list结构存储用户订阅的币种信息 …… 说一下Java的特征 面向对象,封装、继承、多态 封装 利用抽象数据类型将数据和基于...
  • springMVC搭建

    2016-02-20 14:02:00
    简化开发,提升性能 AOP面向切面的编程 声明式事务支持 方便程序的调试 方便集成各大优秀的框架 Java源代码学习的典范 2.Java的面向对象,继承、封装和多态(IOC) Java的本质是什么:面向对象 对象是怎么创建的:new...
  • 本文是基于虹软人脸识别SDK V3.0 Android Java的demo,封装后输出的一个简单的的APK程序,直接安装到手机即可体验功能,供初次接触者快速体验人脸识别功能,便于做算法选型、调研及上级汇报! 2.APK程序获取 APK...
  • Android对日志进行优化

    2018-03-10 18:13:15
    怎么快速的屏蔽这些日志。 解决方法:作为一个Java学了几年的人了,抽离封装的思想基本上要贯穿于我们每次开发中,不管用什么框架我们都不能直接使用该框架,而是将这个框架抽离出一层。 抽离我们的Log日志 ...

空空如也

空空如也

1 2 3
收藏数 60
精华内容 24
关键字:

java怎么快速封装

java 订阅