MyBatis   开源的数据持久化层框架

实体类与SQL语句之间建立映射关系

一:MyBatis前身是IBatis,本是Apache的一个开源的项目,

基于SQL语法,简单易学 ,是耦合度降低,方便程序调式

二:搭建Mybatis的开发步骤:

a:下载mybatis-3.3.3.jar包并导入工程

b.编写MyBatis核心配置文件(configuration.xml)

c.创建实体类-POJO

d.DAO层-SQL映射文件(mapper.xml)

e.创建测试类

读取全局配置文件mybatis-config.xml

创建SqlSessionFactory对象,读取配置文件

创建SqlSession对象

调用mapper文件进行数据操作

我的大配置(全局配置里)

<configuration>
<properties resource="database.properties"/>
<environments default="development">
<settings>
<setting name="LogImpl" value="LOG4J"> </setting>
</settings>
<environment id="development">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${driver}"></property>
<property name="url" value="${url}"></property>
<property name="username" value="${user}"></property>
<property name="userpwd" value="${password}"></property>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="cn/smbms/dao/user/UserMapper"
</mappers>
</properties>
</configuration>

小配置:

在dao层:

<mapper namespace="cn.smbms.dao.user.UserMapper">
<!--查询用户表的记录数-->
<select id="count" resultType="int">
select count() as count from login
</select> </mapper>
在userMapperTest:

public class UserMapperTest{

private Logger logger=Logger.getLogger(UserMapperTest.class);

@Test

public void test(){

     string resource="mybatis-config.xml"

     int count=;

     SqlSession sqlsession=null;

try{

//1.获取mybatis-config.xml输入流

      Inputstream is=Resources.getResourceAsStream(resource)

//2.创建SqlSessionFactory对象,完成对配置文件的读取

      SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is).

//3.创建SqlSession

      sqlSession=factory.openSession();

//4.调用mapper文件来对数据文件进行操作,必须将mapper文件引入到

     count=sqlSession.selectOne("cn.smbms.dao.user.UserMapp");

     logger.debug("UserMapper"+count);
}catch(IoException e){
e.printStackTrace();
}finally{
sqlSession.close(); }

优缺点:

优点:

与JDBC相比,减少了50%以上的代码量

小巧易学

提供XML标签,支持编写动态SQL

提供映射标签

缺点:

数据库移植性差

编写工作量大

MyBatis专注于SQL本身,是一个足够灵活得DAO层解决方案

适用于性能要求较高或者需求多变的互联网项目

四:::::基本要素:::::

三个基本要素:

1. 核心接口和类:

SqlSessionFactoryBuilder

SqlSessionFactory

SqlSession

2. mybatis-config.xml

3.mapper.xml    SQL映射文件

共用的Util工具类

MyBatisUtil:

public class MyBatisUtil{
private static SqlSessionFactory factory;
static{
try{
InputStream is=Resources.getResourceAsStream("");
factory=new SqlSessionFactoryBuilder().bulid(is);
}catch(IOException e){
e.printStackTrace();
} }
public static SqlSession createSqlSession(){ return factory.openSession(false);
} public static void closeSqlSession(SqlSession sql){
if(null!=sqlSession){
sqlSession.close();
} }
}

核心配置文件:

environments元素:

1.表示MyBatis的多套运行环境,将SQL映射到多个不同的数据上。

2.子元素节点:environment,但是必须指定其中一个默认运行环境(通过default指定)

transactionManager-事物管理器

<transactionManager type="[JDBC|MANAGED]"/>  ======>>MANAGED(托管)

3.dataSource元素使用基本的JDBC数据源接口来配置JDBC连接对象的资源

三种内建的数据源类型:

<dataSource type="[UNPOOLED|POOLED|JNDI]"/>

复杂对象:map

所有对象 ===  增删改查 ===一级缓存二级缓存

public interface StudentDao {
//查询所有信息
public List<Student> selectStudent() throws Exception;
//主键id查询
public Student getById(int ID);
//添加学生
public int addStudent(Student stu) throws Exception;
//修改学生
public int upStudent(Student stu) throws Exception;
//删除学生
public int delStudent(int ID) throws Exception;
//模糊条件查询:学生姓名是豆,并且年龄在10岁以上的
public List<Student> ConditionStudent(Student stu) throws Exception;
//findStudent<map>集合 多条件查询1
public List<Student> findStudent(Map<String,Object> map);
//按照索引号查询 多条件查询2
public List<Student> ConditionParameters(String StuName,int StuAge) ;
//智能标签if 检测用户是否录入学生姓名和年龄
public List<Student> findByIf(Student stu) throws Exception;
//智能标签choose 检测用户是否录入学生姓名和年龄
public List<Student> findByChoose(Student stu) throws Exception;
//智能标签foreach 检测In(或者)
public List<Student> findByForeach(int[] arg) throws Exception;
//智能标签foreach List<Integer> 检测In(或者)
public List<Student> ForeachList(List<Integer> list) throws Exception;
//智能标签foreach List<Student> 检测In(或者)
public List<Student> ForeachListStudent(List<Student> list) throws Exception;
//if-set
public int getset(Student stu);
//01.查询指定老师教的学生 多对多
public RTeacher getStudentByTid(int id);
//根据父分类编号,检索该父类编号对应的所有子分类的集合==============递归方法
public List<Category> getChildrenByPid(int pid);
}

小配置文件里:

<mapper namespace="cn.zixin.dao.StudentDao">
<!--二级缓存第二步-->
<cache/>
<!--SQL片段-->
<sql id="columns">
ID,StuName,StuAge,StuTime
</sql>
<!--查询所有的resultMap的用法:-->
<resultMap id="studentmap" type="Student">
<id column="ID" property="ID"></id>
</resultMap>
<select id="selectStudentS" resultMap="studentmap">
select <include refid="columns"></include> from student
</select>
<!--查询所有-->
<select id="selectStudent" resultType="Student">
select * from student
</select>
<!--通过id查询-->
<select id="getById" resultType="Student">
select * from student where ID=#{ID}
</select>
<!--添加学生-->
<insert id="addStudent">
INSERT INTO student(StuName,StuAge,StuTime) VALUE (#{StuName},#{StuAge},#{StuTime})
</insert>
<!--修改学生-->
<update id="upStudent">
UPDATE student SET StuName=#{StuName} WHERE ID=#{ID}
</update>
<!--删除学生-->
<delete id="delStudent">
DELETE from student where ID=#{ID}
</delete> <!--模糊查询学生-->
<!--SELECT * from student WHERE StuName like concat('%',#{StuName},'%') AND StuAge>#{StuAge}-->
<!--可以被SQL注入到 SELECT * from student WHERE StuName like '%${StuName}%' AND StuAge>#{StuAge}-->
<select id="ConditionStudent" resultType="Student">
SELECT * from student WHERE StuName like '%' #{StuName} '%' AND StuAge>#{StuAge}
</select>
<!-- MAP集合查询 多条件查询-->
<select id="findStudent" resultType="Student">
select * from student where StuName like '%' #{StuName} '%' AND StuAge>#{StuAge}
</select> <!-- <resultMap id="Student" type="Student">
<id property="id" column="id"></id>
<result column="StuName" property="StuName"></result>
<result property="StuAge" column="StuAge"></result> </resultMap>
-->
<!--根据索引查询-->
<select id="ConditionParameters" resultType="Student">
SELECT * FROM student WHERE StuName like '%' #{} '%' and StuAge >#{}
</select>
<!--智能标签if 检测用户是否录入学生姓名和年龄-->
<select id="findByIf" resultType="Student">
SELECT * FROM student
<where>
<if test="StuName!=null"> <!--用户录入的姓名字段-->
AND StuName LIKE '%'#{StuName}'%'
</if>
<if test="StuAge!=null">
AND StuAge>#{StuAge}
</if>
</where>
</select>
<!--智能标签Choose 检测用户是否录入学生姓名和年龄-->
<select id="findByChoose" resultType="Student">
SELECT * FROM student
<where>
<choose>
<when test="StuName!=null">
AND StuName LIKE '%'#{StuName}'%'
</when>
<when test="StuAge!=null">
AND StuAge>#{StuAge}
</when>
<otherwise>
AND =
</otherwise>
</choose>
</where>
</select> <!--智能标签Foreach Array 检测In(或者)-->
<select id="findByForeach" resultType="Student">
SELECT * FROM student
<where>
<if test="array.length>0">
ID IN
<foreach collection="array" open="(" close=")" separator="," item="aD">
#{aD}
</foreach>
</if>
</where>
</select> <!--智能标签Foreach List<Integer> 检测In(或者)-->
<select id="ForeachList" resultType="Student">
SELECT * FROM student
<where>
<if test="list.size>0">
ID IN
<foreach collection="list" open="(" close=")" separator="," item="ID">
#{ID}
</foreach>
</if>
</where>
</select> <!--智能标签Foreach List<student> 检测In(或者)-->
<select id="ForeachListStudent" resultType="Student">
SELECT * FROM student
<where>
<if test="list.size>0">
ID IN
<foreach collection="list" open="(" close=")" separator="," item="stu">
#{stu.ID}
</foreach>
</if>
</where>
</select>
<!--if-set-->
<update id="getset" >
UPDATE student
<set>
<if test="StuName!=null" >StuName=#{StuName},</if>
<if test="StuAge!=null">StuAge=#{StuAge},</if>
</set>
WHERE ID=#{ID}
</update> <!--查询指定老师教的学生 多对多-->
<resultMap id="stuMapper" type="RTeacher">
<id column="tid" property="tid"></id>
<result column="tname" property="tname"></result>
<collection property="stus" ofType="RStudent">
<id column="sid" property="sid"></id>
<result column="sname" property="sname"></result>
</collection>
</resultMap>
<select id="getStudentByTid" resultMap="stuMapper" parameterType="RTeacher">
SELECT sname,sid,tid,tname
FROM student2,teacher,teacher_student
WHERE student2.sid=teacher_student.studentid
AND teacher.tid=teacher_student.teacherid
AND tid=#{tid}
</select>

测试类里:

    //查询
@Test
public void findsStudent() {
List<Student> list = myBatis.getSession().selectList("selectStudentS");
for (Student item : list) {
System.out.println(item.getStuName());
}
} //id查询
@Test
public void getById() {
/* //映射关系第一种Class<T>类型
Class<StudentText> aClass = StudentText.class;
//映射关系第二种
try {
Class<StudentText> name = ( Class<StudentText>)Class.forName("cn.zixin.test.StudentText");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}*/
//映射关系第三种 getMapper
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student byId = dao.getById(1);
System.out.println(byId.getStuName());
//Student stu= session.selectOne("getById",1);
// System.out.println(stu.getStuName());
session.commit();
session.close();
} //增加
@Test
public void addStudent() throws Exception {
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student stu = new Student();
stu.setStuName("豆豆");
stu.setStuAge(29);
stu.setStuTime(new Date());
dao.addStudent(stu);
session.commit(); //增删改 手动提交事务
System.out.println("ok");
session.close();
} //修改
@Test
public void upStudent() throws Exception {
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student stu = new Student();
stu.setStuName("豆豆");
stu.setID(2);
dao.upStudent(stu);
session.commit(); //增删改 手动提交事务
System.out.println("ok");
session.close();
} //删除
@Test
public void delStudent() throws Exception {
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
dao.delStudent(2);
session.commit(); //增删改 手动提交事务
System.out.println("ok");
session.close();
} //模糊查询
@Test
public void ConditionStudent() throws Exception {
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student stu = new Student();
stu.setStuName("豆");
stu.setStuAge(30);
List<Student> list = dao.ConditionStudent(stu);
for (Student item : list) {
System.out.println(item.getStuName());
}
session.commit(); //增删改 手动提交事务
System.out.println("ok");
session.close();
} //findStudent<map>集合 多条件查询
@Test
public void mapsStudent() throws Exception {
SqlSession session = myBatis.getSession();
StudentDao dao = session.getMapper(StudentDao.class);
Map<String,Object> map=new HashMap<String,Object>();
map.put("StuName","豆");
map.put("StuAge",20);
List<Student> list = dao.findStudent(map);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
session.close();
} //按照索引号查询
@Test
public void ConditionParameter() {
String StuName = "豆";
int StuAge = 20;
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).ConditionParameters(StuName,StuAge);
for (Student stu : list) {
System.out.println(stu.getStuName());
}
}
@Test
//智能标签if
public void findByIf() throws Exception {
Student stu = new Student();
stu.setStuName( "豆");
stu.setStuAge( 29);
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).findByIf(stu);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
}
@Test
//智能标签choose
public void findBychoose() throws Exception {
Student stu = new Student();
stu.setStuName( "豆");
stu.setStuAge( 29);
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).findByChoose(stu);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
} @Test
//智能标签foreach array
public void findByForeach() throws Exception {
int[] arg={2,5};
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).findByForeach(arg);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
} @Test
//智能标签foreach List<Integer>
public void foreachList() throws Exception {
List<Integer> lists=new ArrayList<Integer>();
lists.add(2);
lists.add(5);
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).ForeachList(lists);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
} @Test
//智能标签foreach List<Student>
public void foreachListStudent() throws Exception {
List<Student> lists=new ArrayList<Student>();
Student s1=new Student();
s1.setID(2);
Student s2=new Student();
s2.setID(5);
lists.add(s1);
lists.add(s2);
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).ForeachListStudent(lists);
for (Student item : list) {
System.out.println(item.getStuName());
}
System.out.println("ok");
} @Test
// 多表联查 一对多 单条SQL
public void selectOne() throws Exception {
Dept dept = myBatis.getSession().getMapper(IdeptDao.class).getEmpsByDeptNO(1);
System.out.println(dept.getDeptname());
for (Emp emp:dept.getEmps()){
System.out.println(emp.getEmpname());
}
System.out.println("ok");
} @Test
// 多表联查 一对多 多条SQL
public void selectmoen() throws Exception {
Dept dept = myBatis.getSession().getMapper(IdeptDao.class).getEmpsByDeptNoMutilSQL(1);
System.out.println(dept.getDeptname());
for (Emp emp:dept.getEmps()){
System.out.println(emp.getEmpname());
}
System.out.println("ok");
}
@Test
// 多对一 根据员工的编号,获取员工姓名 和 部门名称 单条SQL
public void selectManyToOne() throws Exception {
Emp emp = myBatis.getSession().getMapper(IdeptDao.class).getEmpByEmpNo(1);
System.out.println(emp.getEmpname());
System.out.println(emp.getDept().getDeptname());
System.out.println("ok");
}
@Test
// 多对一 根据员工的编号,获取员工姓名 和 部门名称 多条SQL
public void selectMany() throws Exception {
Emp emp = myBatis.getSession().getMapper(IdeptDao.class).getEmpByEmpNoMutilSQL(1);
System.out.println(emp.getEmpname());
System.out.println(emp.getDept().getDeptname());
System.out.println("ok");
}
@Test
//if-set
public void testIsSet() throws Exception {
Student stu=new Student();
stu.setStuName("欣欣");
stu.setStuAge(10);
stu.setID(1);
int i = myBatis.getSession().getMapper(StudentDao.class).getset(stu);
System.out.println(i);
}
@Test
//多对多 查询指定老师教的学生
public void testManyToMany() throws Exception {
RTeacher teacher = myBatis.getSession().getMapper(StudentDao.class).getStudentByTid(1);
System.out.println(teacher.getTname());
for (RStudent stu:teacher.getStus()){
System.out.println(stu.getSname());
}
System.out.println("ok");
}
@Test
//自连接测试=======递归
public void testSelf() throws Exception {
List<Category> list= myBatis.getSession().getMapper(StudentDao.class).getChildrenByPid(0);
for (Category item : list) {
System.out.println(item);
}
System.out.println("ok");
}
@Test
//一级缓存 存在性的证明
public void testOneLevelCache() throws Exception {
List<Student> list = myBatis.getSession().getMapper(StudentDao.class).selectStudent();
for (Student item : list) {
System.out.println(item);
}
System.out.println("============一级缓存");
List<Student> list1 = myBatis.getSession().getMapper(StudentDao.class).selectStudent();
for (Student item : list1) {
System.out.println(item);
} System.out.println("ok");
} @Test
//增删改对一级缓存的影响
public void testUpdateHashSomeThinngToOneLevelCache() throws Exception {
Student Stu=new Student();
Stu.setID(6);
Stu.setStuName("件件");
Stu.setStuAge(12);
int i = myBatis.getSession().getMapper(StudentDao.class).addStudent(Stu);
System.out.println(i);
System.out.println("============一级缓存"); System.out.println("ok");
}

一对多 === 多对多

接口类里:

public interface IdeptDao {
//一对多 单条SQL实现方法
public Dept getEmpsByDeptNO(int deptno);
//一对多 多条SQL实现方法
public Dept getEmpsByDeptNoMutilSQL(int deptno);
//多对一 单条SQL 根据员工的编号,获取员工姓名 和 部门名称
public Emp getEmpByEmpNo(int empno);
//多对一 多条SQL 根据员工的编号,获取员工姓名 和 部门名称
public Emp getEmpByEmpNoMutilSQL(int empno);
}

在我的小配置里:

<mapper namespace="cn.zixin.dao.IdeptDao">
<!--一对多 单条SQL实现方法-->
<resultMap id="deptMapper" type="Dept">
<id column="deptno" property="deptno"></id>
<result column="deptname" property="deptname"></result>
<collection property="emps" ofType="Emp">
<id property="empno" column="empno"></id>
<result column="empname" property="empname"></result>
</collection>
</resultMap> <select id="getEmpsByDeptNO" resultMap="deptMapper">
select dept.deptno,deptname,empno,empname from dept,emp where dept.deptno=emp.deptno and dept.deptno=#{deptno}
</select> <!--一对多 多条SQL实现方法-->
<resultMap id="deptMappers" type="Dept">
<id column="deptno" property="deptno"></id>
<result column="deptname" property="deptname"></result>
<collection property="emps" ofType="Emp" select="deptBy" column="deptno"></collection>
</resultMap> <select id="deptBy" resultType="Emp">
SELECT * FROM emp WHERE deptno=#{deptno}
</select> <select id="getEmpsByDeptNoMutilSQL" resultMap="deptMappers">
select deptno,deptname from dept where deptno=#{deptno}
</select> <!--多对一 根据员工的编号,获取员工姓名 和 部门名称 单条SQL-->
<resultMap id="empMapper" type="Emp">
<id column="empno" property="empno"></id>
<result column="empname" property="empname"></result>
<association property="dept" javaType="Dept">
<id column="deptno" property="deptno"></id>
<result column="deptname" property="deptname"></result>
</association> </resultMap> <select id="getEmpByEmpNo" resultMap="empMapper">
select dept.deptno,deptname,empno,empname from dept,emp where dept.deptno=emp.deptno and empno=#{empno}
</select> <!-- 多对一 多条SQL 根据员工的编号,获取员工姓名 和 部门名称-->
<resultMap id="empMutiMapper" type="Emp">
<id column="empno" property="empno"></id>
<result column="empname" property="empname"></result>
<association property="dept" javaType="Dept" select="selectDeptByDeptNo" column="deptno">
</association> </resultMap>
<select id="selectDeptByDeptNo" resultType="Dept">
SELECT * from Dept where deptno=#{deptno} </select> <select id="getEmpByEmpNoMutilSQL" resultMap="empMutiMapper">
select deptno,empno,empname from emp where empno=#{empno}
</select> </mapper>

注解:所有的测试类里都有所有的接口测试

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。

iBATIS一词来源于"internet"和"abatis"的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)

我们把Mybatis的功能架构分为三层:

(1)API接口层:提供给外部使用的接口API,开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

(2)数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

(3)基础支撑层:负责最基础的功能支撑,包括连接管理、事务管理、配置加载和缓存处理,这些都是共用的东西,将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

MyBatis 最强大的特性之一就是它的动态语句功能。如果您以前有使用JDBC或者类似框架的

经历,您就会明白把SQL语句条件连接在一起是多么的痛苦,要确保不能忘记空格或者不要在

columns列后面省略一个逗号等。动态语句能够完全解决掉这些痛苦。

尽管与动态SQL一起工作不是在开一个party,但是MyBatis确实能通过在任何映射SQL语句中

使用强大的动态SQL来改进这些状况。

动态SQL元素对于任何使用过JSTL或者类似于XML之类的文本处理器的人来说,都是非常熟悉

的。在上一版本中,需要了解和学习非常多的元素,但在MyBatis 3 中有了许多的改进,现在只

剩下差不多二分之一的元素。MyBatis使用了基于强大的OGNL表达式来消除了大部分元素。

mybatis大框架的更多相关文章

  1. SSM(SpringMVC+Spring+Mybatis)框架学习理解

    近期做到的项目中,用到的框架是SSM(SpringMVC+Spring+Mybatis).之前比较常见的是SSH.用到了自然得了解各部分的分工 spring mvc 是spring 处理web层请求的 ...

  2. 3大框架Struts、Hibernate、Spring简单了解

    3大框架:Struts.Hibernate.Spring 基本概念:Spring/Struts/Hibernate是干嘛用的? 三个框架产生的技术历史背景 学习前首先应该掌握的基础知识 学习一个开发框 ...

  3. SSM(spring,springMVC,Mybatis)框架的整合

    这几天想做一个小项目,所以搭建了一个SSM框架. 1.基本概念 1.1.Spring   Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Joh ...

  4. 一篇文章带你掌握MyBatis简化框架——MyBatisPlus

    一篇文章带你掌握MyBatis简化框架--MyBatisPlus 我们在前面的文章中已经学习了目前开发所需的主流框架 类似于我们所学习的SpringBoot框架用于简化Spring开发,我们的国人大大 ...

  5. Android开发用过的十大框架

    http://blog.csdn.net/u011200604/article/details/51695096 本文系多方综合与转载整合,意在Android开发中能够知道和使用一些好用的第三方支持, ...

  6. web前端之HTML的大框架(body元素与frameset元素)

    web前端之HTML的大框架      body元素与frameset元素 对于从事html的人员来说,我们一般熟悉的框架是先声明html ,然后在<html>标签对里包着<head ...

  7. 注解与反射 ---Spring与Mybatis等框架的实现原理

    Java中各大框架,无论是AOP 还是 IoC 其基本实现思路都是源自Java 运行时支撑的反射功能, 而反射最基本的一点就是 任何一个类 其在JVM环境中,都有一个对象的Class对象,这个对象提供 ...

  8. spring+springMVC+mybatis的框架项目基础环境搭建

    上一个项目在后台用到spring+springMVC+mybatis的框架,先新项目初步需求也已经下来,不出意外的话,应该也是用这个框架组合. 虽然在之前activiti相关的学习中所用到的框架也是这 ...

  9. RAC优化大框架的分配(jumbo frame)

    RAC优化大框架的分配(jumbo frame) 首先讲讲MTU的概念:在网络通信中,有个MTU(Max Transmission Unit)的概念,即网络传输中最大帧的大小,这个值默认是1500By ...

随机推荐

  1. 第一个PSP0级

    1.计划: 需求描述: 按照图片要求设计添加新课程界面.(0.5分) 在后台数据库中建立相应的表结构存储课程信息.(0.5分) 实现新课程添加的功能. 要求判断任课教师为王建民.刘立嘉.刘丹.王辉.杨 ...

  2. 2016级算法期末上机-E.中等·ModricWang's Fight with DDLs II

    1125 ModricWang's Fight with DDLs II 思路 圆内被划分部分数的计算方式如下: 圆内部的每一个交点都使得总份数增加了一:除此之外,每一根直线段最后抵达圆周时,总份数也 ...

  3. json兼容ie8

    今天遇到一个问题,后台传递过来的json对象,在前端解析的时候用JSON.parse(result)方法不好使,查了一下是因为ie浏览器的问题.然后在网上翻了翻,找到了这个办法,可以使这个函数在ie中 ...

  4. Go语言指针

    指针简介 (Pointer)是编程语言中的一个对象,利用地址,它的值直接指向(points to)存在电脑存储器中另一个地方的值.由于通过地址能找到所需的变量单元,可以说,地址指向该变量单元.因此,将 ...

  5. WPF实现WORD 2013墨迹批注功能

    1 前言 WORD 2013可以使用墨迹在文档上面标注,本文讲述通过WPF第三方控件实现类似主要功能如下: 名称 描述 墨迹标注 不论是否触摸屏环境下可以开始墨迹功能,并实现鼠标/触摸在文档任意位置绘 ...

  6. 搭建类似生产环境的RAC

    install the necessary packages yum install -y 创建组.用户和目录 创建用户组 groupadd -g 2000 oinstallgroupadd -g 2 ...

  7. rpm: error while loading shared libraries: libgcc_s.so.1: cannot open shared object file: No such file or directory解决办法

    不多说,直接上干货! 问题详情 [root@bigdatamaster app]# rpm -qa | grep gcc rpm: error : cannot open shared object ...

  8. python-Event事件线程同步和互斥

    #!/usr/bin/python #coding=utf-8 #用于线程间通信,通过事件标识控制 import threading from time import sleep,ctime def ...

  9. 3D效果

    3D transform:rotate3d(x,y,z,a) (0.6,1,0.5,45deg) transform-origin 允许改变转换元素的位置,(中心点) transform-style ...

  10. 断开所有远程连接(sql server)

    DECLARE @d VARCHAR(8000) SET @d = ' ' SELECT @d = @d + ' kill ' + CAST(spid AS VARCHAR) + CHAR(13)FR ...