键盘瞎
键盘瞎

Hibernate--day01

非本人总结的笔记，抄点笔记复习复习。感谢传智博客及黑马程序猿


Hibernate--day01_第1张图片
记笔记啊记笔记

Hibernate的简介

什么是Hibernate

Hibernate：冬眠。对类进行实例化操作，这里类指的是之前说的javabean，javabean正确的叫法：实体类 entity
Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库****ORM****框架
Hibernate具体实现的操作：
Hibernate的是开源轻量级的框架，对jdbc的代码进行封装，程序员不需要写底层的sql语句的代码，就可以实现对数据库的操作。实现对数据库的crud操作。

Javaee中有三层结构
Web层：struts2
Service层：spring
持久化层（dao层）：hibernate框架

Hibernate是使用在持久化层的框架

Jdbc底层代码的步骤：
1 加载驱动
2 创建连接
3 对sql语句进行预编译操作
4 设置参数，执行sql语句
5 释放资源

什么是ORM

ORM: object relational mapping , 对象关系映射
ORM 就是通过将Java对象映射到数据库表，通过操作Java对象，就可以完成对数据表的操作
做操作时候，有实体类 ，有数据库表 ，
在hibernate中，让实体类和数据库进行映射对应的关系（配置文件配置），
操作实体类就相当于操作数据库表中的数据

Hibernate--day01_第2张图片
画图分析过程

流行数据库框架

JPA Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系（只有接口规范）

Hibernate 最流行ORM框架，通过对象-关系映射配置，可以完全脱离底层SQL

MyBatis 本是apache的一个开源项目 iBatis，支持普通 SQL查询，存储过程和高级映射的优秀持久层框架

Apache DBUtils 、Spring JDBCTemplate

Hibernate的优点

  1. Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
  2. Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作
  3. Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性
  4. Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系

Hibernate的版本

Struts2 版本 2.3.15
Hibernate 版本 3.6.10
Hibernate 3.x 4.x 5.x

1、下载hibernate3.x的开发包 (3.6.10)
http://sourceforge.net/projects/hibernate/files/hibernate3/

Hibernate--day01_第3张图片
Hibernate开发包

2.jar包作用

Hibernate--day01_第4张图片
Hibernate的jar包作用

Hibernate的入门案例

Hibernate的开发环境搭建

第一步：导入hibernate的核心的jar包

1、导入hibernate的核心的jar包

Hibernate--day01_第5张图片
Hibernate核心jar包

2、导入lib里面的required里面的所有的jar包

​

Hibernate--day01_第6张图片
required的jar包

​

Hibernate--day01_第7张图片
jar包

3、导入lib里面jpa中所有的jar包

​

Hibernate--day01_第8张图片
jpa的jar包

4、hibernate需要日志的输出

​ hibernate本身不支持日志输出，导入第三方支持日志输出的jar包（两个）

Hibernate--day01_第9张图片
日志输出jar包

​

Hibernate--day01_第10张图片
日志输出

5、导入数据库驱动的jar包

加上数据库驱动jar包一共有 11个
​

Hibernate--day01_第11张图片
jar包

第二步：创建实体类 user类

package cn.itcast.entity;

import java.util.Date;

/**
 * 实体类
 */
public class User {

    private Integer id;
    private String username;
    private Date birthday;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }   
}

第三步：创建Hibernate的核心配置文件

1、Hibernate的核心配置文件

名称必须是 hibernate.cfg.xml，位置放到 src下面

hibernate.cfg.xml配置文件位置

2、在核心配置文件中引入dtd约束

3、配置的相关信息

（1）配置数据库的相关内容

（2）配置hibernate的相关内容



    
    
        com.mysql.jdbc.Driver
    
    
        jdbc:mysql:///hibernate_day01
    
    root
    root
    
    
        org.hibernate.dialect.MySQLDialect
    

    
    
    true
    
    true
    
    update

第四步：配置实体类和数据表映射关系

1、创建映射配置文件，文件格式xml

但是这个文件映射配置文件名称和位置没有要求，一般建议：命名(实体类.hbm.xml) 位置：放到实体类所在的包里面

映射文件位置

2、映入dtd约束

3、配置实体类和表映射关系

第五步：在Hibernate的核心配置文件中映入映射文件

因为hibernate只会加载核心配置文件，其他文件不会加载

如果没有在核心文件中引入映射文件，出现错误

可以在myeclipse 直接把映射文件拖到核心配置文件里就可以了

异常

实现添加操作

使用hibernate代码实现crud操作，步骤是固定
第一步 加载核心配置文件
第二步 创建sessionFactory
第三步 使用sessionFactory创建session
第四步 开启事务
第五步 写具体逻辑（crud）
第六步 提交事务
第七步 关闭资源

  package cn.itcast.hibernate.test;
  import java.util.Date;
  import java.util.List;
  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.hibernate.cfg.Configuration;
  import org.junit.Test;

  import cn.itcast.entity.User;
  import cn.itcast.utils.HibernateUtils;

  /**

 实现hibernate的crud的操作
   */
  public class TestDemo1 {

      //实现添加操作
      @Test
      public void add() {
          //加载核心配置文件
          Configuration cfg = new Configuration();
          cfg.configure();
          //创建sessionFactory
          SessionFactory sessionFactory = cfg.buildSessionFactory();
          //打开session
          Session session = sessionFactory.openSession();
          //开启事务
          Transaction tx = session.beginTransaction();
          //写添加逻辑
          //项数据库设置值
          User user = new User();
          user.setUsername("lucy");
          user.setBirthday(new Date());
          //调用session里面的方法 save方法,保存的意思
          session.save(user);
          //提交事务
          tx.commit();
          //关闭连接
          session.close();
          sessionFactory.close();
      }
  }

Hibernate的配置文件详解（hibernate.cfg.xml）

1、hibernate中加载核心配置文件

要求

  1. 位置：放到src下
  2. 名称：必须是hibernate.cfg.xml

配置三部分

  1. 配置数据库信息（必须的）
  2. 配置hibernate的相关信息（不是必须的）
  3. 配置引入的映射文件（如果有映射文件必须配置）

2、映射配置文件

位置和名称没有固定要求

Hibernate--day01_第12张图片
映射配置文件

核心API使用

Configuration类（管理Hibernate的配置信息）

Configuration 类负责管理 Hibernate 的配置信息。包括如下内容：

加载hibernate.properties 和 hibernate.cfg.xml

持久化类与数据表的映射关系（*.hbm.xml文件）

创建Configuration 的两种方式

​ 属性文件（hibernate.properties）:

Configuration cfg = new Configuration(); //手动加载hbm

​ Xml文件（hibernate.cfg.xml）

Configuration cfg = newConfiguration().configure();

在核心配置文件中引入映射配置文件
之前做法：

语句

还有另外方式加载映射配置文件（了解）
​

Hibernate--day01_第13张图片
加载配置文件

SessionFactory接口（获取Session对象）

Configuration对象根据当前的配置信息生成SessionFactory对象

SessionFactory对象中保存了当前数据库配置信息和所有映射关系以及预定义的SQL语句

SessionFactory对象是线程安全的

SessionFactory还负责维护Hibernate的二级缓存

Configuration configuration = new Configuration().configure();

创建sessionFactory

SessionFactory sessionFactory = configuration.buildSessionFactory();

可以通过SessionFactory对象 获得Session对象

Session session = sessionFactory.openSession();

构造SessionFactory 很消耗资源，一般情况下一个应用只初始化一个

☆抽取HibernateUtils 用来提供Session对象

创建HibernateUtils

package cn.itcast.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * 创建sessionFactory对象
 */
public class HibernateUtils {
    
    static Configuration cfg = null;
    static SessionFactory sessionFactory  = null;
    //静态代码块
    static {
        cfg = new Configuration();
        cfg.configure();
        //创建sessionFactory
        sessionFactory  = cfg.buildSessionFactory();
    }

    //提供得到Session的方法
    public static Session getSession() {
        Session session = sessionFactory.openSession();
        return session;
    }
}

使用工具类得到session对象

package cn.itcast.hibernate.test;

import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo1 {

    //实现添加操作
    @Test
    public void addTestSession() {
        //根据工具类得到session对象
        Session session = HibernateUtils.getSession();
        //开启事务
        Transaction tx = session.beginTransaction();
        //写添加逻辑
        User user = new User();
        user.setUsername("jacktom");
        user.setBirthday(new Date());
        //调用session里面的方法 save方法
        session.save(user);
    
        //提交事务
        tx.commit();
        //关闭连接
        session.close();
        //sessionFactory不需要关闭了
//      sessionFactory.close();
    }
}

Session接口（CRUD操作）

调用Session里面的方法，实现crud操作

Session是单线程对象，只能有一个操作时候，不能同时多个操作使用，不要把Session变量定义成成员变量，每次使用都创建新对象，相当于JDBC的Connection

Session是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心；Session是线程不安全的

所有持久化对象必须在session 的管理下才可以进行持久化操作

Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久化操作的数据都缓存在 session 对象处

持久化类与 Session 关联起来后就具有了持久化的能力

常用方法

方法 作用
save()/persist() 、update() 、saveOrUpdate() 增加和修改对象
delete() 删除对象
get()/load() 根据主键查询
createQuery()、createSQLQuery() 数据库操作对象
createCriteria 条件查询

Transaction接口(事务)

代表数据库操作的事务对象

Transactiontransaction = session.beginTransaction();

提供事务管理的方法

commit():提交相关联的session实例

rollback():撤销事务操作

wasCommitted():检查事务是否提交

回顾：
什么是事务

两个操作：提交和回滚

事务特性：原子性、一致性、隔离性、持久性

不考虑隔离性产生问题：脏读、不可重复读、虚读

在jdbc中，使用jdbc代码实现添加操作，默认事务自动提交

在hibernate中，事务默认不是自动提交的，需要手动配置，手动代码提交

如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务

让hibernate事务提交有两种：
第一种： 通过配置方式设置hibernate是自动提交

自动提交

产生问题：第一个save方法添加数据，但是添加之后出现异常，第二个添加不能完成

Hibernate--day01_第14张图片
示例

第二种：手动代码方式控制事务

  package cn.itcast.hibernate.test;

  import java.util.Date;
  import java.util.List;

  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.hibernate.cfg.Configuration;
  import org.junit.Test;

  import cn.itcast.entity.User;
  import cn.itcast.utils.HibernateUtils;

  /**
   *实现hibernate的crud的操作
   *
   */
  public class TestDemo1 {

      //事务操作
      @Test
      public void testTx() {

          //根据工具类得到session对象

          Session session = null;
          //开启事务
          Transaction tx = null;
          try {

              session = HibernateUtils.getSession();
              tx = session.beginTransaction();

              //实现两次添加操作
              //写添加逻辑

              User user = new User();
              user.setUsername("jacktom");
              user.setBirthday(new Date());

              //调用session里面的方法 save方法
              session.save(user);
      
              //发生异常
              int a = 1/0;
            
              User user1 = new User();
              user1.setUsername("lilei");
              user1.setBirthday(new Date());

              //调用session里面的方法 save方法
              session.save(user1);

              //提交
              tx.commit();
          }catch(Exceptione) {
              e.printStackTrace();
              //回滚
              tx.rollback();
          }finally {
              //关闭session
              session.close();
          }
      }
  }

Query接口(HQL语句查询操作)

Query代表面向对象的一个Hibernate查询操作

session.createQuery 接受一个HQL语句

HQL是Hibernate Query Language缩写，语法很像SQL语法，但是完全面向对象的

使用Query对象步骤

    获得Hibernate Session对象

    编写HQL语句

​ 调用session.createQuery 创建查询对象

​ 如果HQL语句包含参数，则调用Query的setXXX设置参数

​ 调用Query对象的list() 或uniqueResult() 方法执行查询

Query还包含两个方法 用于控制返回结果

​ setFirstResult(intfirstResult) 设置返回结果从第几条开始

​ setMaxResults(intmaxResults) 设置本次返回结果记录条数

实现查询的操作

Query query = session.createQuery(“hql语句”)

query.list(); 返回集合

package cn.itcast.hibernate.test;


import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo1 {
    
    //query使用
    @Test
    public void testQuery() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            //查询表中所有的记录
            //hql语句   User是实体类的名称
            Query query = session.createQuery("from User");
            List list = query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
}

Hibernate实现crud操作（重点）

功能具体介绍

（1）添加操作save

调用Session里的save（实体类对象），不需要设置对象的id值

User user = new User();
user.setUsername("jackTom");
user.setBirthday(new Date());
session.save(user);//调用Session里的save方法

（2）根据主键查询操作

调用Session里面的get方法

get方法里面有两个参数：

参数 值
参数一 返回实体类的Class
参数二 id值 
User user = (User)session.get(User.class, 1);//调用Session里面的get方法

（3）修改操作update

调用session里面的方法update方法
update方法里面传递参数有一个：
修改之后的值，封装到实体类对象，这个对象中必须有id值

做修改操作时候实现的步骤： 首先 根据id把原始信息查询出来 其次，设置要修改的值 最后，调用update方法实现

User user = new User();
user.setId(2);
user.setUsername("东方不败");

session.update(user);

img

做修改操作时候实现的步骤：
首先 根据id把原始信息查询出来
其次，设置要修改的值
最后，调用update方法实现 

//修改：根据id修改
//修改id=1的username，修改为其他值
//根据id查询出来对象
User user = (User)session.get(User.class, 1);
//设置对象中，要修改的值
user.setUsername("大腹便便");
//调用update方法实现
session.update(user);

Hibernate--day01_第15张图片
img

（4）删除操作delete

调用session里面的方法 delete方法

Delete方法中传递一个参数： 实体类对象，对象中至少要有一个id值

实现方式有两种
第一种 先查询出来对象，再调用delete方法删除

//删除id是4的记录
//查询id是4的记录
User user = (User)session.get(User.class, 4);
//调用delete方法
session.delete(user)

Hibernate--day01_第16张图片
img

第二种 创建对象，设置id值，再调用delete方法删除

//删除id是3的记录
//创建对象
User user = new User();
//设置id值
user.setId(3);
//调用delete方法删除
session.delete(user);

（5）查询操作(3种)hql sql qbc

查询表中所有记录

第一种 使用hql查询

//创建query对象
Query query = session.createQuery("from User");
//调用query里面list方法返回list集合
List list = query.list();
for(User user : list){
    System.out.println(user);
}

第二种 使用本地sql查询（会用）

//创建对象
SQLQuery query = session.createSQLQuery("select * from user");
//调用query里面的方法
//返回list集合，每部分不是对象形式，而是数据形式
List list = query.list();
for(Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

crud代码演示:

package cn.itcast.hibernate.test;


import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo2 {
    
    //根据主键查询
    @Test
    public void testGet() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //调用session里面get方法
            User user = (User) session.get(User.class, 1);
            
            System.out.println(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }   

    //本地sql查询
    @Test
    public void testSQL() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //创建对象
            SQLQuery query = session.createSQLQuery("select * from user");
            //调用query里面的方法
            //返回list里面，每部分不是对象形式，而是数组形式
            List list = query.list();
            for (Object[] objects : list) {
                System.out.println(Arrays.toString(objects));
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //hql语句查询   Query
    @Test
    public void testHQL() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //创建query对象
            Query query = session.createQuery("from User");
            //调用query里面list方法返回list集合
            List list = query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //第二种直接删除操作(不建议使用)
    @Test
    public void testDeleteDemo2() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //删除id是3的记录
            //创建对象
            User user = new User();
            //设置id值
            user.setId(2);
            //调用delete方法删除
            session.delete(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //第一种删除操作(先查询在删除方法)建议使用
    @Test
    public void testDeleteDemo1() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //删除id是4的记录
            //查询id是4的对象
            User user = (User) session.get(User.class, 4);
            //调用delete方法
            session.delete(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //修改操作(先查询在修改)
    @Test
    public void testUpdateSuccess() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //修改：根据id修改
            // 修改id=1的username，修改为 其他值
            //根据id查询出来对象
            User user = (User) session.get(User.class, 1);
            //设置对象中，要修改成的值
            user.setUsername("大腹便便");
            //调用update方法实现
            session.update(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
    
    //修改操作(直接修改)
    @Test
    public void testUpdate() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //修改：根据id修改
            // 修改id=2的username，修改为 东方不败
            //创建实体类对象
            //操作实现修改，但是问题：
            //调用update方法之后，把表里面所有字段都修改
            //只是设置id和username值，根据id修改username和birthday
            User user = new User();
            user.setId(2);
            user.setUsername("东方不败");
            
            session.update(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
    
}

基本数据类型和包装类使用

回顾：
Java中基本数据类型 有8个 byte short int long float double char boolean
对应的包装类：
​ int---Integer char---Character，其他是首字母大写

​ 在实体类中使用基本数据类型还是使用包装类？
都是使用包装类。

考试成绩。
可以使用类型 int 和 包装类 Integer
一般都使用 包装类

表示 学生得分是 0 分
int score = 0;
Integer score = 0;

表示学生是否参加考试
int score = 0;
Integer score = null;

Hibernate的主键oid

什么是oid

在java中，区分不同的对象，根据对象的地址
在数据库中，区别不同的记录，根据主键id值

现在是实体类和数据库映射关系
在java中没有主键，在数据库里面没有地址

使用hibernate的OID区别不同的对象，如果OID相同的就是一个对象

自然主键和代理主键
自然主键：
Oid和业务相关的属性或者字段
比如人的身份证号码

代理主键：
Oid和业务不相关的属性和字段
比如写id

配置Hibernate的oid

使用id标签

有name属性 值写 实体类属性名称

Column属性值 写数据库表字段

在id标签里面使用 generator，配置oid

有class属性值 oid主键的生成策略

Hibernate的oid主键生成策略

Increment和identity

使用increment作为生成策略，生成建表语句中没有AUTO_INCREMENT自动增长

使用identity作为生成策略，生成的语句中 有AUTO_INCREMENT自动增长

Hibernate--day01_第17张图片
hibernate的主键生成策略

详解:

Hibernate--day01_第18张图片
increment标识符生成器
Hibernate--day01_第19张图片
identity标识符生成器
Hibernate--day01_第20张图片
sequence标识符生成器
Hibernate--day01_第21张图片
native标识符生成器
Hibernate--day01_第22张图片
uuid32位标识符生成器
Hibernate--day01_第23张图片
assigned标识符生成器

你可能感兴趣的:(Hibernate--day01)

  • Hibernate--day01 键盘瞎
    非本人总结的笔记，抄点笔记复习复习。感谢传智博客及黑马程序猿记笔记啊记笔记Hibernate的简介什么是HibernateHibernate：冬眠。对类进行实例化操作，这里类指的是之前说的javabean，javabean正确的叫法：实体类entityHibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库****ORM****框架Hibernate具体实现的操作：Hibern
  • 枚举的构造函数中抛出异常会怎样 bylijinnan javaenum单例
    首先从使用enum实现单例说起。 为什么要用enum来实现单例？ 这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
  • CMake 教程 aigo C++
    转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/   CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
  • cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 springWebgis
      cvc-complex-type.2.3: Element 'beans' cannot have character     Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
  • jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
    <script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的 高度，兼容ie,ff,chrome var top = document.documentElement.s
  • 将数据库中的数据转换成dbs文件 何必如此 sqldbs
    旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：         主要生成数据库配置文件(.conf文
  • 在IBATIS中配置SQL语句的IN方式 357029540 ibatis
    在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
  • Spring3 MVC 笔记（一） 7454103 springmvcbeanRESTJSF
             自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 要看业务，和整体的设计！      最近公司要求开发个新系统！
  • Timer与Spring Quartz 定时执行程序 darkranger springbean工作quartz
    有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
  • 大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
    大端小端转换，le32_to_cpu 和cpu_to_le32  字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html         小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
  • Nginx负载均衡配置实例详解 avords
    [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 负载均衡 先来简单了解一下什么是负载均衡
  • 乱说的 houxinyou 框架敏捷开发软件测试
    从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！ 这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多， 瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。 也可以把软件开发理
  • 欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
    　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
  • 包冲突问题的解决方法 bingyingao eclipsemavenexclusions包冲突
    包冲突是开发过程中很常见的问题： 其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 抛如下异常： java.lang.NoClassDefFoundError: Could not in
  • 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
    先来一段废话： 实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
  • sudoku solver in Haskell bookjovi sudokuhaskell
    这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。   现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
  • java apache ftpClient bro_feng java
    最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
  • 读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
  • 面试记录语 chenyu19891124 招聘
    或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
  • Fire Workflow 1.0正式版终于发布了 comsci 工作workflowGoogle
    Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了 正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
  • Python向脚本传参 daizj python脚本传参
    如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 需要模块：sys 参数个数：len(sys.argv) 脚本名：    sys.argv[0] 参数1：     sys.argv[1] 参数2：     sys.argv[
  • 管理用户分组的命令gpasswd dongwei_6688 passwd
    NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
  • 郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  • yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
    页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
  • linux mysql fypop linux
    enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
  • Scramble String hcx2013 String
    Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
  • 跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
    历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。     ----广告-----------------------------------------------------
  • nginx日志切割并使用flume-ng收集日志 liyonghui160com
         nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
  • Oracle死锁解决方法 pda158 oracle
    　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
  • java之List排序 shiguanghui list排序
       在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
  • servlet单例多线程 utopialxw 单例多线程servlet
    转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和   http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他