Redis底层原理(1)

你可能不知道自己的潜力有多大，尽情的来吧。 –RuiDer

Before

  • Java基础
  • Spring
  • Mabatis
  • Redis
  • Belief

Redis概念介绍

1
2
3
4
Redis:一款NoSql技术，面向Java Web。它就是一个简单的基于内存的数据库，
并提供持久化服务。Redis和MongoDB是当前使用最广泛的NoSql，主要应对每秒
几十万的读写操作，其性能远远超过数据库。并且在高并发下保证数据的一致性和
安全性。

Redis优势

  • 使用ANSI C语言完成，接近汇编语言，运行速度快
  • 基于内存读/写，读写速度相当快。
  • 支持6种数据结构，分别是字符串String，链表List，集合Set，散列hash，和基数HyperLogLog，以及有序集合Zset，规则相对较少，处理快。

综上优势，Redis的读写速度更快。。

Redis使用

1
2
3
4
Redis的使用有两种方式：
	- 与Spring结合Spring-Data-Redis(RedisTemplate对象操作)
	- Jedis操作Redis的数据读写
两种方式的使用截然不同。

缓存

1
2
3
4
5
6
7
8
9
10
持久化数据库的缺点与优点：
	-数据从数据库读取也就是索引磁盘速度慢
	-数据写如数据库速度还说的过去
在Java Web领域，对于数据库的操作读的操作远超过写的操作，一般是1:9到3:7 的比例。对于
数据库中的数据，读取操作会直接进行整个磁盘的索引，而索引整个磁盘的速度是非常慢的，但是
读取内存的速度就不一样了，会非常速度。

缓存的缺点：
	磁盘的容量一般是TGB级别，不同于内存的小容量一般是GB级别，容量有限，而且磁盘十分
	廉价，内存价格也比磁盘昂贵。

何时使用缓存Redis

1
2
3
4
5
6
7
因为缓存基于内存，内存空间有限，价格高贵，所以应该有条件限制
使用Redis的条件：
	- 数据使用频繁，读取操作多于写操作
	- 业务数据经常被使用吗？命中率如何？
	- 业务数据大小如何？
一般而言，缓存的作用主要用于存储一些常用的数据，
比如用户登录信息，银行卡信息等。。

Redis缓存简单原理

1
2
3
4
5
6
使用缓存是因为缓存的读取速度快，而考虑到写操作时，数据库的写操作与其速度差不到那去，
所以直接考虑缓存的读取操作
- 当第一次读取数据时，首先检测Redis中是否含有该数据
- 如果有直接读取
- 如果没有，从数据库读取，写入Redis
- 第二遍读取数据时，直接从缓存中读取了

高速读/写场合

1
2
3
4
5
在互联网行业，对于高并发业务，比如秒杀和抢红包这些业务，
需要高质量的缓存机制相应千万级别的访问量。如果使用数据库，
数据库每秒处理万级别的sql语句，简直是异想天开，有时会使数据库瘫痪，甚至有时
会使服务器奔溃。
	在这样的场合一般考虑使用异步写入数据库。

异步写入数据库

1
2
3
4
5
6
7
	对于高速读/写场合中单单使用Redis的场景，把这些需要高速读/写的数据，
缓存到Redis中，而在满足一定条件时，触发这些缓存的数据写入数据库中去。
	细细解释一下这个问题，当一个请求发送数据当服务器时，一开始存储数据是
Redis缓存，没有进行任何关于数据库的操作，但是缓存不能持久化，因此需要
需要把这些数据存入数据库，因此会在一定条件时判断一个请求是否结束，一旦结束，
就会将缓存中的数据更新到数据库。而这个条件就像秒杀或者抢红包业务中红包数量
是否为0，如果为空，一次性写入数据库，完成持久化工作。

Redis的原理解析

此部分需要从两个方面为读者解读，不管是配置也好还是代码堆积也好，他们之间紧紧地联系在一起，读者可以参考阅读。

  • Spring环境下的Redis配置细节
  • Java环境下的Jedis操作

Spring IOC原理简单回忆

SpringIoc控制反转技术简单的理解就是管理我们日常所用的JavaBean类或者对象，因为一个Bean对象拥有属性和它们各自对应的getter和setter方法等，（只是简单的举JavaBean对象，其他对象也可以），SpringIoc容器干了什么呢？通过我们人为的配置，SpringIOC会在容器中保存对应的Bean对象。下面代码介绍：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.ruider;
public class Person{
	private String name;
	private int age;
	/** getter and setter **/
}


这是一个Person类，拥有属性name和age
初始化一个对象：

Person a=new  Person();
a.setName("a");
a.setAge(20);

再看看我们的Spring中的配置

<Bean id="person" class="com.ruider.Person">
	<property name="name" value="a"/>
	<property name="age" value="20"/>
</Bean>

使用配置获取Person对象

@Autowired
Person a=null;

不管是Java代码式创建对象还是使用SpringIOC容器获取对象，他们都是等价的。
理解这一点会有助于后面的Redis原理解析。

###Redis属性以及连接池的属性
Redis：（connectionFactory常用的）

1
2
3
4
5
- jedisCOnfig连接池配置信息
- port端口，一般是6379
- host或者localhost
- password 密码
- TIMEOUT 超时

Redis连接池：（JedisPoolConfig常用）

1
2
3
- 最大空闲数MaxIdle
- 最大连接数MaxTotal
- 最大等待时间MaxWaitingTimes

Redis使用对象RedisTemplate属性

1
2
3
- connectionFactory连接工厂（相当于连接池）
- keySerializer Redis键序列化转换类型
- valueSerializer Redis值序列化转换类型

Redis配置式redis-config.xml

根据上述的三种属性介绍进行Redis的属性配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
     http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.2.xsd"
    default-autowire="byName" default-lazy-init="true">

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>
    <!-- redis服务器中心 -->
    <bean id="connectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="poolConfig" />
        <property name="port" value="${redis.port}" />
        <property name="hostName" value="${redis.host}" />
        <property name="password" value="${redis.password}" />
        <property name="timeout" value="${redis.timeout}"></property>
    </bean>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean
                class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
    </bean>

（1）其中对于JedisPoolConfig连接池的配置

1
2
3
4
5
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

至此，JedisPoolConfig的对象已经存储在SpringIOC容器中，在程序应用中可以通过@Autowired获取JedisPoolConfig的对象。

上面JedisPoolConfig的配置用Java语句实现如下：

1
2
3
4
5
6
7
8
public class JedisPoolDemo{
	public static void main(String[] args){
		JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
		jedisPoolConfig.setMaxIdle(20);   //连接池最大空闲数
		jedisPoolConfig.setMaxTotal(100);  //连接池最大连接数
		jedisPoolConfig.setMaxWaitingMillis(2000);//最大等待时间为2秒
	}
}

（2）其中ConnectionFactory的配置如下

1
2
3
4
5
6
7
8
<bean id="connectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="poolConfig" />
        <property name="port" value="${redis.port}" />
        <property name="hostName" value="${redis.host}" />
        <property name="password" value="${redis.password}" />
        <property name="timeout" value="${redis.timeout}"></property>
    </bean>

至此ConnectionFactory的对象已经存储在SpringIOC容器中，在程序应用中可以通过@Autowired获取JedisPoolConfig的对象。

上面ConnectionFactory的配置用Java语句实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
	//JedisPoolConfig设置
	JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
	jedisPoolConfig.setMaxIdle(20);   //连接池最大空闲数
	jedisPoolConfig.setMaxTotal(100);  //连接池最大连接数
	jedisPoolConfig.setMaxWaitingMillis(2000);//最大等待时间为2秒
	 
	 //ConnectionFactory的设置
	ConnectionFactory connectionFactory=new ConnectionFactory(jedisPoolConfig);
	connectionFactory.setHost("localhost");   
	connectionFactory.setPort("6379");  
	connectionFactory.setTimeOut(2000);
}

（3）其中RedisTemplate的配置如下：

1
2
3
4
5
6
7
8
9
10
11
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean
                class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
    </bean>

至此RedisTemplate的对象已经存储在SpringIOC容器中，在程序应用中可以通过@Autowired获取RedisTemplate的对象。

上面ConnectionFactory的配置用Java语句实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class RedisTempalteDemo{
	public static void main(String[] args){
		//JedisPoolConfig设置
		JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
		jedisPoolConfig.setMaxIdle(20);   //连接池最大空闲数
		jedisPoolConfig.setMaxTotal(100);  //连接池最大连接数
		jedisPoolConfig.setMaxWaitingMillis(2000);//最大等待时间为2秒
		 
		 //ConnectionFactory的设置
		ConnectionFactory connectionFactory=new ConnectionFactory(jedisPoolConfig);
		connectionFactory.setHost("localhost");   
		connectionFactory.setPort("6379");  
		connectionFactory.setTimeOut(2000);
		
		//RedisTemplate设置
		RedisTemplate redisTemplate=new RedisTemplate();
		redisTemplate.setConnectionFactory(connectionFactory);
		//Seriallizer设置
		StringSerializer stringSerializer=new StringSerializer();
		redisTemplate.setKeySerializer(stringSerializer);
		redisTemplate.setValueSerializer(stringSerializer);
	}
}

补充上面redis-config.xml用到的属性配置

新建redis.properties

1
2
3
4
5
6
7
8
9
10
11
#redis setting  
redis.host=127.0.0.1
redis.port=6379
redis.password=123456
redis.maxIdle=100
redis.maxActive=300
redis.maxWait=1000
redis.testOnBorrow=true
redis.timeout=100000

fep.local.cache.capacity =10000

Redis底层原理

篇幅太长，详情在Redis的底层有介绍，主要介绍一些Redis的命令以及这些命令被Java封装的使用方式。

About Me

我的个人博客
我的Github

展开全文 >>

Redis简单理解

好久不来，甚是想念。 –[RuiDer]

before

  • Java基础
  • JDBC数据库

    Redis

    1
    2
    3
    4
    Redis:一款NoSql技术，面向Java Web。它就是一个简单的基于内存的数据库，
    并提供持久化服务。Redis和MongoDB是当前使用最广泛的NoSql，主要应对每秒
    几十万的读写操作，其性能远远超过数据库。并且在高并发下保证数据的一致性和
    安全性。

Redis优势

  • 使用ANSI C语言完成，接近汇编语言，运行速度快
  • 基于内存读/写，读写速度相当快。
  • 支持6种数据结构，分别是字符串String，链表List，集合Set，散列hash，和基数HyperLogLog，以及有序集合Zset，规则相对较少，处理快。

综上优势，Redis的读写速度更快。。

Redis使用

1
2
3
4
Redis的使用有两种方式：
	- 与Spring结合Spring-Data-Redis
	- Jedis操作Redis的数据读写
两种方式的使用截然不同。

缓存

1
2
3
4
5
6
7
8
9
10
持久化数据库的缺点与优点：
	-数据从数据库读取也就是索引磁盘速度慢
	-数据写如数据库速度还说的过去
在Java Web领域，对于数据库的操作读的操作远超过写的操作，一般是1:9到3:7 的比例。对于
数据库中的数据，读取操作会直接进行整个磁盘的索引，而索引整个磁盘的速度是非常慢的，但是
读取内存的速度就不一样了，会非常速度。

缓存的缺点：
	磁盘的容量一般是TGB级别，不同于内存的小容量一般是GB级别，容量有限，而且磁盘十分
	廉价，内存价格也比磁盘昂贵。

何时使用缓存Redis

1
2
3
4
5
6
7
因为缓存基于内存，内存空间有限，价格高贵，所以应该有条件限制
使用Redis的条件：
	- 数据使用频繁，读取操作多于写操作
	- 业务数据经常被使用吗？命中率如何？
	- 业务数据大小如何？
一般而言，缓存的作用主要用于存储一些常用的数据，
比如用户登录信息，银行卡信息等。。

Redis缓存简单原理

1
2
3
4
5
6
使用缓存是因为缓存的读取速度快，而考虑到写操作时，数据库的写操作与其速度差不到那去，
所以直接考虑缓存的读取操作
- 当第一次读取数据时，首先检测Redis中是否含有该数据
- 如果有直接读取
- 如果没有，从数据库读取，写入Redis
- 第二遍读取数据时，直接从缓存中读取了

高速读/写场合

1
2
3
4
5
在互联网行业，对于高并发业务，比如秒杀和抢红包这些业务，
需要高质量的缓存机制相应千万级别的访问量。如果使用数据库，
数据库每秒处理万级别的sql语句，简直是异想天开，有时会使数据库瘫痪，甚至有时
会使服务器奔溃。
	在这样的场合一般考虑使用异步写入数据库。

异步写入数据库

1
2
3
4
5
6
7
	对于高速读/写场合中单单使用Redis的场景，把这些需要高速读/写的数据，
缓存到Redis中，而在满足一定条件时，触发这些缓存的数据写入数据库中去。
	细细解释一下这个问题，当一个请求发送数据当服务器时，一开始存储数据是
Redis缓存，没有进行任何关于数据库的操作，但是缓存不能持久化，因此需要
需要把这些数据存入数据库，因此会在一定条件时判断一个请求是否结束，一旦结束，
就会将缓存中的数据更新到数据库。而这个条件就像秒杀或者抢红包业务中红包数量
是否为0，如果为空，一次性写入数据库，完成持久化工作。

After

我的CSDN
我的GitHub

展开全文 >>

倒排索引

因为热爱，所以拼搏。 –RuiDer

前导必备

  • Java基础
  • 数据库

正常索引使用

1
2
3
4
5
6
7
8
9
比如一张数据库表table，有id和content两个字段，表中数据如下：
		id        content
		1          abc
		2           fg
		3          ahu
		4          bgf
使用id=2进行索引查找fg。
select from table where id=2;
即可查询到相应的值。

问题

1
2
3
4
现在我们可以根据数据库表中的id可以查询对应的值，但是有一些问题，
当我们想要查询fg值的id是多少或者我们想要知道哪些conten中含有a（或者b）。
这就是我们日常生活中经常使用的一个算法：当你搜索一首歌时，你可以不知道它的全名，
但是当你输入其中一部分文字时，音乐平台会自动提示或者推荐了一些相似的歌名。

解决问题的算法—–倒排索引算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
思路：（通俗的理解）
		上述中的表table：
			   id        content
				1          abc
				2           fg
				3          ahu
				4          bgf
		我们的目的：通过content值或者content值中的某个字母查找对应的id
		我们是不是可以根据上述的表table模拟出为下面的表table1：
				content     id
					a       1,3
					b       1,4
					c       1
					f       2,4
					g       2,4
					h       3
		模拟分析：新建表是按照字母作为索引进行新建，将之前table中的content值按照content值中含有的字母进行分类，比如
		第一个content索引值为a，之前的table表中含有a的content
有id=1（abc）,id=3(ahu)。

这就是倒排索引算法的思路。

倒排索引

倒排索引也叫反向索引，倒序索引。

倒排索引的使用场景

  • 全局搜索：比如在整个数据库中查找单词word
  • 模糊查询
  • 关键字查询

About Me

我的CSDN

我的GitHub

展开全文 >>

Java基本数据类型

因为热爱，所以拼搏。 –RuiDer

Java基本数据类型及占用字节大小

- byte: 8位，一个字节
- short: 16位，两个字节
- char: 16位，两个字节
- int: 32位，四个字节
- float: 32位，四个字节
- long : 64位，八个字节
- double: 64位，八个字节
- boolean: 8位，一个字节

了解更多

我的GitHub

我的CSDN

展开全文 >>

乐观锁

因为热爱，所以拼搏。 –RuiDer

前导必备

  • Java并发锁的含义
  • 悲观锁
  • 数据库

    高并发

    1
    2
    3
    4
    5
    6
    7
    	高并发简单理解就是在服务器中，成千上完个客户端在同一时间内发
    起对服务器端的请求，包括数据的请求，这时服务器后端需要在极短时内处
    理客户端的请求并且响应，在互联网平台，追求的是速度和时间，所以，
    这就对服务器端有非常大的考验。
    	一般客户端发起请求，服务器端接到请求，首先去处理相应的数据，
    这就涉及到数据库中的数据操作，或者是缓存中的数据处理，总之要与数据库打交道。
    操作数据库数据包括数据的查询，编辑，更新等。

高并发产生的问题

1
2
3
4
5
6
   不同的线程在同一时间对同一数据的读取和更新产生冲突。可能会出现线程A读取
的数据不是最新值，线程B更新的数据覆盖其他线程对该数据的更新。这些问题
都是高并发带来的，即高并发产生的问题。
高并发冲突分类：
	- 数据丢失
	- 脏读

锁

1
2
3
4
5
6
Java提供锁的支持，通俗的理解就是锁对某些数据具有保护作用，防止某一数据在同一时间
被多个线程操作。
锁的分类：
	- 悲观锁：持保守态度，只能由某一个线程持有，其他线程等待持有锁的线程释放锁。性能差
	- 乐观锁：下面讲
	- 其他锁：像自旋锁，轻量级锁等

乐观锁概念

1
2
3
4
	对于每一个数据或者数据集合，设有一个标识version（字段），
当线程读取数据时，同时会读取出标识版本version的值，进行更
新时，首先比较当前数据库字段version的值是否与读取出的
version值相等，如果相等，则更新值，否则，作为过期值丢弃。

乐观锁的实现

1
2
3
4
5
6
7
8
9
10
11
实现一：
		比如一个数据库表的结构是
		id value version三个字段
		当进行数据的更新时，首先读取：
		select value version from table where id=x;
		其次更新：
			update table set value=newValue, version=oldVersion+1 where id=x and version=oldVersion;

实现二：
	cas算法：Compare And Swap算法，即有三个值，内存值，预期旧值，新值，
比较内存值是否与当前预期值相等，如果相等，则替换新值，否则，不做任何处理。

about me

我的博客

我的CSDN

展开全文 >>

Mybatis缓存

因为热爱，所以拼搏。 –RuiDer

前导必备

- 数据库
- Mybatis

Mybatis缓存

Mybatis提供缓存支持，志在提升开发的性能。数据库数据的索引一般是基于磁盘的，而内存和高速缓存相对磁盘的读写速度相当快，基本是磁盘读写数据的十倍。尤其在互联网开发中，追求速度，缓存为性能提供捷径。Mybatis缓存包括一级缓存和二级缓存，一级缓存基于SqlSession层面，二级缓存基于SqlSessionFactory层面。

一级缓存和二级缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
缓存：将sql语句select查询出来对应的POJO对象进行缓存，供后续SqlSession对象使用。

一级缓存
	条件：
	- 同一个SqlSession对象
	- 同一个sql查询语句
	当同一个SqlSession对象进行两次相同select语句查询时，第一次会执行sql语句进行数据库的索引，
之后将所查询数据对应的POJO对象进行缓存；第二次执行相同参数的sql语句查询前，不会像第一次执行sql语句，
而是直接从缓存中索引数据对象。所以说，一级缓存是基于SqlSession的。不同的SqlSession对象的缓存不可以
共享，不能相互访问。为了解决相互共享问题，Mybatis提供二级缓存解决该问题。注意，一级缓存对每个SqlSession
对象要求他们在所有sql语句后必须执行commit语句，否则，不存在一级缓存。

	二级缓存
	条件：
	- 同一个SqlSessionFactory对象
	- 不同的SqlSession对象
	- 共享POJO对象、
	二级缓存是相对SqlSessionFactory对象而言的，同一个SqlSessionFactory创建的不同的SqlSession对象，
可以共享该SqlSessionFactory下的所有POJO对象，也就是数据库数据的共享。但是二级缓存要求对应的POJO类需要实现
序列化，也就是实现java.io.Serializable接口。

一级缓存 和 二级缓存 的配置

1
2
3
4
5
6
7
8
一级缓存：Mybatis默认一级缓存，只要每个SqlSession对象执行commit语句，都会存在一级缓存。
二级缓存：
	<cache
	...sql语句...
	/>
	加入上述语句，就会开启二级缓存。二级缓存会进行序列化和反序列化的过程，所以说POJO
必须要实现Seriaizable接口。二级缓存cache元素会将select出来的POJO对象进行缓存，对于
insert,update,delete sql语句二级缓存会自动刷新。

二级缓存配置cache元素配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//cache接口源码
public interface Cache{
	//获取缓存id
	public int getId();
	
	//保存POJO对象,key为键，value为值
	public void putObject(Object key,Object value);

	//获取POJO对象
	public Object getObject(Object key);
	
	//清除缓存
	void clear();

	//获取缓存大小
	public int getSize();
	
	//获取读写锁,主要是多线程时使用
	ReadWriteLock getReadWriteLock();
}

配置Redis或者MongoDB缓存处理

1
2
3
<cache type="com....RedisCache">
	<property name="Host" value="localHost">
</cache>

我的GitHub

我的博客

展开全文 >>

Mybatis N+1问题解析

因为热爱，所以拼搏。 –RuiDer

前导必备

  • Mybatis
  • 数据库
  • 级联

    N+1问题？？

    N+1问题来源于数据库中常见的级联技术，即N个数据库表形成关联关系，当再增加一个关联表时，也就是N+1个级联关系，由于某些时候，我们并不需要加载数据库的所有数据，而是某一个数据库表中数据，这时Mybatis会自动加载所有表的数据，多执行几条无关sql语句，会造成数据库资源的浪费以及系统性能的下降，这就是级联表的缺点。

    如何解决N+1问题

    Mybatis本身给出解决方案，就是延迟加载。

    延迟加载

    延迟加载会解决上述的N+1问题，也就是在N+1个级联表的情况下，只加载需求的数据库表数据。这是互联网发展的需求，性能提升的途径。

    如何配置Mybatis完成延迟加载

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    全局配置：
    	- lazyLoadingEnabled        true/false
    	- aggressiveLazyLoading      true/false
    	
    	lazyLoadingEnabled:延迟加载的全局开关，当开启时，所有关联都会延迟加载。在特定的关联中，
    使用fetchType属性覆盖该内容的功能。fetchType将在后面介绍。

    	aggressiveLazyLoading：是层级延迟加载开关，什么意思呢？就是处于同一个层级的关联表会同
    时延迟加载，或者同时被加载。
    	
    	配置：
    		在Mybatis的全局配置中的setting标签中加入设置
    		<setting>
    			<setting name="lazyLoadingEnabled" value="true"/>
    			<setting name="aggressiveLazyLoading" value="true"/>
    		</setting>

全局配置的缺点

上面的配置属于全局配置，会出现一个问题，同一个层级的级联表也存在需求性的差异，同一级的某个数据库表的数据或许不是我们经常使用的，那么上述的配置也会影响系统的性能。

全局配置的优化 — fetchType属性

Mybatis使用fetchType属性解决全局配置的缺点。fetchType出现在级联元素association,collection中，它存在两个值

1
2
3
4
5
6
7
	- eager:获得当前POJO后立即加载对应的数据。
	- lazy:获得当前POJO后延迟加载对应的数据。
	
配置：
		<collection properties=".." column=".." fetchType="eager"
			select="映射接口"
		/>

我的github

我的博客

展开全文 >>

EJB简单理解

因为热爱，所以拼搏。 –RuiDer

什么是JavaEE

JavaEE:Java Platform Enterprise Edition
JavaEE是一个分层架构，分布式的体系结构。

1
2
3
4
5
分层架构： JavaEE由四个层次构成，分别是客户层，Web层，业务层，持久层
			客户层：页面展示层，运行在客户机上，可以访问Web层和业务层。
			Web层：JSP和Servlet构成的Web页面。
			业务层：处理程序的业务逻辑，主要是一些业务方法的集合。主要框架有Spring，SpringMVC，Struts，EJB框架等
			持久层：数据库层，JDBC，JNDI，DataSource等，主要一流框架有Mybatis,Hibernate框架等

什么是EJB

EJB:Enterprise Java Bean,一个重量级的业务层框架，重量级的意思在于其启动时开销大。

主要组成

  1. Remote接口：定义业务逻辑方法。
  2. Home接口： 定义获取EJB对象的方法。
  3. Enterprise Bean类：实现Remote接口，具体方法可以包括数据库的连接，数据库的具体增删改查操作。

EJB与Spring可以比较着学习，参考源码学习。

展开全文 >>

DataSource数据源简单理解

因为热爱，所以拼搏。 –RuiDer

什么是数据源

JDBC2.0 提供了javax.sql.DataSource接口，它负责建立与数据库的连接，当在应用程序中访问数据库时
不必编写连接数据库的代码，直接引用DataSource获取数据库的连接对象即可。用于获取操作数据Connection对象。

数据源与数据库连接池

1
2
数据源建立多个数据库连接，这些数据库连接会保存在数据库连接池中，当需要访问数据库时，只需要从数据库连接池中
获取空闲的数据库连接，当程序访问数据库结束时，数据库连接会放回数据库连接池中。

数据源DataSource与JNDI

1
数据源DataSource是JNDI资源的一种，很简单，就是将“DataSource”字符串名称与真正的DataSource对象绑定起来，方便获取。

数据库连接池的优势

1
2
3
4
5
6
传统的JDBC访问数据库技术，每次访问数据库都需要通过数据库驱动器Driver和数据库名称以及密码等等资源建立数据库连接。
这样的连接存在两大问题：

1. 频繁的建立数据库连接与断开数据库，这样会消耗大量的资源和时间，降低性能。

2. 数据库的连接需要用户名和密码等等，这些需要一定的内存和CPU一定开销。

展开全文 >>

JNDI简单理解

因为热爱，所以拼搏。 –RuiDer

什么是JNDI技术

JNDI: Java Naming And Directory Interface,通俗的理解就是将名称与对象绑定在一起，对象工厂负责生产出对象，这些对象与特定的名称绑定。
外部程序通过对象的名称查找对象资源并使用资源。

JNDI原理

1
2
3
4
5
6
7
8
9
10

//javax.naming包负责管理JNDI技术，该包中的Context接口定义了两个方法
//bind: 负责绑定名称和对象
//lookup:通过名称查找对象的作用。

public interface Conterface{

    public void bind(String name，Object obj);
    publiv Object lookup(String name);
}

个人理解：JNDI的底层是一个HashMap结构，将名称和对象使用键值对一一对应，这种关系的搭建与Map体系紧紧相连。

展开全文 >>

本站访客人数: 人次