oracle数据库中in和exists的详细执行过程

in和exist的主要区别体现在对sql执行计划的影响上。

传统上认为，如果子查询的条件更具选择性（selective），就用in；而如果父查询（外层查询）的条件更具选择性（selective），就用exist。

具体的内容可以参考以下oracle原厂的手册，不好意思，oracle的原厂手册都是英文版的。

对于你举的那个例子，用in和用or是一样的，因为它们的执行计划肯定是一样的。

另外需要特别注意的是，in和exist的区别只在10203及以前的版本中存在；而10204及以后的版本中，in和exist的效果是完全一样的，手册中也删除了有关二者区别的说明。

以下是对手册的引用：

In certain circumstances, it is better to use IN rather than EXISTS In general, if the selective predicate is in the subquery, then use IN If the selective predicate is in the parent query, then use EXISTS

Sometimes, Oracle can rewrite a subquery when used with an IN clause to take advantage of selectivity specified in the subquery This is most beneficial when the most selective filter appears in the subquery and there are indexes on the join columns Conversely, using EXISTS is beneficial when the most selective filter is in the parent query This allows the selective predicates in the parent query to be applied before filtering the rows against the EXISTS criteria

补充：

看sql语句看执行计划就可以了，没必要比较某次的时间长短，因为语句执行时间长短跟很多其他因素有关，比如数据是否在buffer cache中（第二次执行一般会比第一次快不少）、数据库负载不同等。对于常量，in的效果完全等同于or，这是毫无疑问的。

　本文将对在Java环境下Memcached应用进行详细介绍。Memcached主要是集群环境下的缓存解决方案，可以运行在Java或者NET平台上，这里我们主要讲的是Windows下的Memcached应用。

这些天在设计SNA的架构，接触了一些远程缓存、集群、session复制等的东西，以前做企业应用的时候感觉作用不大，现在设计面对internet的系统架构时就非常有用了，而且在调试后看到压力测试的情况还是比较好的。

在缓存的选择上有过很多的思考，虽然说memcached结合java在序列化上性能不怎么样，不过也没有更好的集群环境下的缓存解决方案了，就选择了memcached。本来计划等公司买的服务器到位装个linux再来研究memcached，但这两天在找到了一个windows下的Memcached版本，就动手开始调整现有的框架了。

Windows下的Server端很简单，不用安装，双击运行后默认服务端口是11211，没有试着去更改端口，因为反正以后会用Unix版本，到时再记录安装步骤。下载客户端的JavaAPI包，接口非常简单，参考API手册上就有现成的例子。

目标，对旧框架缓存部分进行改造：

1、缓存工具类

2、hibernate的provider

3、用缓存实现session机制

今天先研究研究缓存工具类的改造，在旧框架中部分函数用了ehcache对执行结果进行了缓存处理，现在目标是提供一个缓存工具类，在配置文件中配置使用哪种缓存（memcached或ehcached），使其它程序对具体的缓存不依赖，同时使用AOP方式来对方法执行结果进行缓存。

首先是工具类的实现：

在Spring中配置

Java代码

<bean id="cacheManager"

class="orgspringframeworkcacheehcacheEhCacheManagerFactoryBean">

<property name="configLocation">

<value>classpath:ehcachexmlvalue>

property>

bean>

<bean id="localCache"

class="orgspringframeworkcacheehcacheEhCacheFactoryBean">

<property name="cacheManager" ref="cacheManager" />

<property name="cacheName"

value="×××cacheLOCAL_CACHE" />

bean>

<bean id="cacheService"

class="×××corecacheCacheService" init-method="init" destroy-method="destory">

<property name="cacheServerList" value="${cacheservers}"/>

<property name="cacheServerWeights" value="${cachecacheServerWeights}"/>

<property name="cacheCluster" value="${cachecluster}"/>

<property name="localCache" ref="localCache"/>

bean>

<bean id="cacheManager"

class="orgspringframeworkcacheehcacheEhCacheManagerFactoryBean">

<property name="configLocation">

<value>classpath:ehcachexmlvalue>

property>

bean>

<bean id="localCache"

class="orgspringframeworkcacheehcacheEhCacheFactoryBean">

<property name="cacheManager" ref="cacheManager" />

<property name="cacheName"

value="×××cacheLOCAL_CACHE" />

bean>

<bean id="cacheService"

class="×××corecacheCacheService" init-method="init" destroy-method="destory">

<property name="cacheServerList" value="${cacheservers}"/>

<property name="cacheServerWeights" value="${cachecacheServerWeights}"/>

<property name="cacheCluster" value="${cachecluster}"/>

<property name="localCache" ref="localCache"/>

bean>

在properties文件中配置${cacheservers} ${cachecacheServerWeights} ${cachecluster}

具体工具类的代码

Java代码

/

@author Marc

/

public class CacheService {

private Log logger = LogFactorygetLog(getClass());

private Cache localCache;

String cacheServerList;

String cacheServerWeights;

boolean cacheCluster = false;

int initialConnections = 10;

int minSpareConnections = 5;

int maxSpareConnections = 50;

long maxIdleTime = 1000 60 30; // 30 minutes

long maxBusyTime = 1000 60 5; // 5 minutes

long maintThreadSleep = 1000 5; // 5 seconds

int socketTimeOut = 1000 3; // 3 seconds to block on reads

int socketConnectTO = 1000 3; // 3 seconds to block on initial

// connections If 0, then will use blocking

// connect (default)

boolean failover = false; // turn off auto-failover in event of server

// down

boolean nagleAlg = false; // turn off Nagle's algorithm on all sockets in

// pool

MemCachedClient mc;

public CacheService(){

mc = new MemCachedClient();

mcsetCompressEnable(false);

}

/

放入

/

public void put(String key, Object obj) {

AsserthasText(key);

AssertnotNull(obj);

AssertnotNull(localCache);

if (thiscacheCluster) {

mcset(key, obj);

} else {

Element element = new Element(key, (Serializable) obj);

localCacheput(element);

}

}

/

删除

/

public void remove(String key){

AsserthasText(key);

AssertnotNull(localCache);

if (thiscacheCluster) {

mcdelete(key);

}else{

localCacheremove(key);

}

}

/

得到

/

public Object get(String key) {

AsserthasText(key);

AssertnotNull(localCache);

Object rt = null;

if (thiscacheCluster) {

rt = mcget(key);

} else {

Element element = null;

try {

element = localCacheget(key);

} catch (CacheException cacheException) {

throw new DataRetrievalFailureException("Cache failure: "

+ cacheExceptiongetMessage());

}

if(element != null)

rt = elementgetValue();

}

return rt;

}

/

判断是否存在

/

public boolean exist(String key){

AsserthasText(key);

AssertnotNull(localCache);

if (thiscacheCluster) {

return mckeyExists(key);

}else{

return thislocalCacheisKeyInCache(key);

}

}

private void init() {

if (thiscacheCluster) {

String[] serverlist = cacheServerListsplit(",");

Integer[] weights = thissplit(cacheServerWeights);

// initialize the pool for memcache servers

SockIOPool pool = SockIOPoolgetInstance();

poolsetServers(serverlist);

poolsetWeights(weights);

poolsetInitConn(initialConnections);

poolsetMinConn(minSpareConnections);

poolsetMaxConn(maxSpareConnections);

poolsetMaxIdle(maxIdleTime);

poolsetMaxBusyTime(maxBusyTime);

poolsetMaintSleep(maintThreadSleep);

poolsetSocketTO(socketTimeOut);

poolsetSocketConnectTO(socketConnectTO);

poolsetNagle(nagleAlg);

poolsetHashingAlg(SockIOPoolNEW_COMPAT_HASH);

poolinitialize();

loggerinfo("初始化memcached pool!");

}

}

private void destory() {

if (thiscacheCluster) {

SockIOPoolgetInstance()shutDown();

}

}

}

/

@author Marc

/

public class CacheService {

private Log logger = LogFactorygetLog(getClass());

private Cache localCache;

String cacheServerList;

String cacheServerWeights;

boolean cacheCluster = false;

int initialConnections = 10;

int minSpareConnections = 5;

int maxSpareConnections = 50;

long maxIdleTime = 1000 60 30; // 30 minutes

long maxBusyTime = 1000 60 5; // 5 minutes

long maintThreadSleep = 1000 5; // 5 seconds

int socketTimeOut = 1000 3; // 3 seconds to block on reads

int socketConnectTO = 1000 3; // 3 seconds to block on initial

// connections If 0, then will use blocking

// connect (default)

boolean failover = false; // turn off auto-failover in event of server

// down

boolean nagleAlg = false; // turn off Nagle's algorithm on all sockets in

// pool

MemCachedClient mc;

public CacheService(){

mc = new MemCachedClient();

mcsetCompressEnable(false);

}

/

放入

/

public void put(String key, Object obj) {

AsserthasText(key);

AssertnotNull(obj);

AssertnotNull(localCache);

if (thiscacheCluster) {

mcset(key, obj);

} else {

Element element = new Element(key, (Serializable) obj);

localCacheput(element);

}

}

/

删除

/

public void remove(String key){

AsserthasText(key);

AssertnotNull(localCache);

if (thiscacheCluster) {

mcdelete(key);

}else{

localCacheremove(key);

}

}

/

得到

/

public Object get(String key) {

AsserthasText(key);

AssertnotNull(localCache);

Object rt = null;

if (thiscacheCluster) {

rt = mcget(key);

} else {

Element element = null;

try {

element = localCacheget(key);

} catch (CacheException cacheException) {

throw new DataRetrievalFailureException("Cache failure: "

+ cacheExceptiongetMessage());

}

if(element != null)

rt = elementgetValue();

}

return rt;

}

/

判断是否存在

/

public boolean exist(String key){

AsserthasText(key);

AssertnotNull(localCache);

if (thiscacheCluster) {

return mckeyExists(key);

}else{

return thislocalCacheisKeyInCache(key);

}

}

private void init() {

if (thiscacheCluster) {

String[] serverlist = cacheServerListsplit(",");

Integer[] weights = thissplit(cacheServerWeights);

// initialize the pool for memcache servers

SockIOPool pool = SockIOPoolgetInstance();

poolsetServers(serverlist);

poolsetWeights(weights);

poolsetInitConn(initialConnections);

poolsetMinConn(minSpareConnections);

poolsetMaxConn(maxSpareConnections);

poolsetMaxIdle(maxIdleTime);

poolsetMaxBusyTime(maxBusyTime);

poolsetMaintSleep(maintThreadSleep);

poolsetSocketTO(socketTimeOut);

poolsetSocketConnectTO(socketConnectTO);

poolsetNagle(nagleAlg);

poolsetHashingAlg(SockIOPoolNEW_COMPAT_HASH);

poolinitialize();

loggerinfo("初始化memcachedpool!");

}

}

private void destory() {

if (thiscacheCluster) {

SockIOPoolgetInstance()shutDown();

}

}

}

然后实现函数的AOP拦截类，用来在函数执行前返回缓存内容

Java代码

public class CachingInterceptor implements MethodInterceptor {

private CacheService cacheService;

private String cacheKey;

public void setCacheKey(String cacheKey) {

thiscacheKey = cacheKey;

}

public void setCacheService(CacheService cacheService) {

thiscacheService = cacheService;

}

public Object invoke(MethodInvocation invocation) throws Throwable {

Object result = cacheServiceget(cacheKey);

//如果函数返回结果不在Cache中,执行函数并将结果放入Cache

if (result == null) {

result = invocationproceed();

cacheServiceput(cacheKey,result);

}

return result;

}

}

public class CachingInterceptor implements MethodInterceptor {

private CacheService cacheService;

private String cacheKey;

public void setCacheKey(String cacheKey) {

thiscacheKey = cacheKey;

}

public void setCacheService(CacheService cacheService) {

thiscacheService = cacheService;

}

public Object invoke(MethodInvocation invocation) throws Throwable {

Object result = cacheServiceget(cacheKey);

//如果函数返回结果不在Cache中,执行函数并将结果放入Cache

if (result == null) {

result = invocationproceed();

cacheServiceput(cacheKey,result);

}

return result;

}

}

Spring的AOP配置如下：

Java代码

<aop:config proxy-target-class="true">

<aop:advisor

pointcut="execution( ×××PoiServicegetOne())"

advice-ref="PoiServiceCachingAdvice" />

aop:config>

<bean id="BasPoiServiceCachingAdvice"

class="×××corecacheCachingInterceptor">

<property name="cacheKey" value="PoiService" />

<property name="cacheService" ref="cacheService" />

bean>

开启数据库缓存，使查询不用每次都完全使用数据库，减小网站压力。

mysql cache功能分析：

1 mysql的cache功能的key的生成原理是：把select语句按照一定的hash规则生成唯一的key，select的结果生成value，即 key=>value。所以对于cache而言，select语句是区分大小写的，也区分空格的。两个select语句必须完完全 全一致，才能够获取到同一个cache。

2 生成cache之后，只要该select中涉及到的table有任何的数据变动(insert，update，delete *** 作等),相 关的所有cache都会被删除。因此只有数据很少变动的table，引入mysql 的cache才较有意义。

所以，mysql的cache功能只适用于下列场合：数据变动较少，select较多的table。

那么。在复杂的系统中，如何使用mysql的cache功能呢，基本方法如下：

配置query_cache_type，同时改写程序。

query_cache_type 0 代表不使用缓冲， 1 代表使用缓冲，2 代表根据需要使用。

设置 1 代表缓冲永远有效，如果不需要缓冲，就需要使用如下语句：

SELECT SQL_NO_CACHE FROM my_table WHERE …

如果设置为 2 ，需要开启缓冲，可以用如下语句：

SELECT SQL_CACHE FROM my_table WHERE …

So，最简单又可靠的做法是：把query_cache_type设置为2，然后在需要提高select速度的地方，使用：

SELECT SQL_CACHE FROM…

的方式进行SELECT。

mysql cache调试笔记

1 可以使用下列命令开启mysql的select cache功能：

SET GLOBAL query_cache_size = 102400000;

因为当query_cache_size默认为0时，是不开启cache功能的。

2 调试：

查看cache的设置：

show variables like ‘%query_cache%’;

性能监控：

show status like ‘%Qcache%’;

3 mysql cache的清理：

可以使用FLUSH QUERY CACHE语句来清理查询缓存碎片以提高内存使用性能。该语句不从缓存中移出任何查询。

RESET QUERY CACHE语句从查询缓存中移出所有查询。FLUSH TABLES语句也执行同样的工作。

Query Cache

当你的数据库打开了Query Cache（简称QC）功能后，数据库在执行SELECT语句时，会将其结果放到QC中，当下一次处理同样的SELECT请求时，数据库就会从QC取得结 果，而不需要去数据表中查询。

在这个“Cache为王”的时代，我们总是通过不同的方式去缓存我们的结果从而提高响应效率，但一个缓存机制是否有效，效果如何，却是一个需要好好 思考的问题。在MySQL中的Query Cache就是一个适用较少情况的缓存机制。在上图中，如果缓存命中率非常高的话，有测试表明在极端情况下可以提高效率238%[1]。 但实际情况如何？Query Cache有如下规则，如果数据表被更改，那么和这个数据表相关的全部Cache全部都会无效，并删除之。这里“数据表更改”包括: INSERT, UPDATE, DELETE, TRUNCATE, ALTER TABLE, DROP TABLE, orDROP DATABASE等。举 个例子，如果数据表posts访问频繁，那么意味着它的很多数据会被QC缓存起来，但是每一次posts数据表的更新，无论更新是不是影响到了cache 的数据，都会将全部和posts表相关的cache清除。如果你的数据表更新频繁的话，那么Query Cache将会成为系统的负担。有实验表明，糟糕时，QC会降低系统13%[1]的处理能力。

如果你的应用对数据库的更新很少，那么QC将会作用显著。比较典型的如博客系统，一般博客更新相对较慢，数据表相对稳定不变，这时候QC的作用会比 较明显。

再如，一个更新频繁的BBS系统。下面是一个实际运行的论坛数据库的状态参数：

QCache_hit 5280438

QCache_insert 8008948

Qcache_not_cache 95372

Com select 8104159

可以看到，数据库一共往QC中写入了约800W次缓存，但是实际命中的只有约500W次。也就是说，每一个缓存的使用率约为066次。很难说，该 缓存的作用是否大于QC系统所带来的开销。但是有一点是很肯定的，QC缓存的作用是很微小的，如果应用层能够实现缓存，将可以忽略QC的效果。

————-下面是关于QC的一些其他细节—————–

一、Query Cache相关参数：

query_cache_size QC占用空间大小，通过将其设置为0关闭QC功能

query_cache_type 0表示关闭QC；1表示正常缓存；2表示SQL_CACHE才缓存

query_cache_limit 最大缓存结果集

query_cache_min_res_unit 手册上说，QC会按照这个值分配缓存block的大小。

Qcache_lowmem_prunes 这是一个状态变量(show status)，当缓存空间不够需要释放旧的缓存时，该值会自增。

二、Query Cache观察：

CREATE TABLE t1(id INT,var1 varchar(10));

//Com_select:8 Qcache_hits:1

INSERT INTO t1 VALUES(1,’>

您好，感谢您选择惠普产品。

Opendooerandclearjan，janinprintpaperpath是提示您打印卡纸了，提示您清除卡纸。一般卡纸位置如下：

I：进纸盒

II:取出硒鼓，检查硒鼓下面是否有卡纸

III:出纸盒位置

也可以下载手册（鼠标右键另存即可下载），>

按照手册中问题解决章节中排除卡纸的详细截图，把机器内部所有卡纸取出，如果没取完整，就可能导致连续卡纸的。在保证机器内部没有卡纸情况下，打印或者复印如果还卡纸，要观察卡纸的位置

1如果卡纸位置不固定，一般都是纸张自身导致，更换80g的标准普通打印纸测试

2如果卡纸位置固定，观察在什么地方

a如果在硒鼓下面，更换原厂硒鼓测试

b如果是其他位置，可能是这个部分硬件有问题，需要联系当地维修中心，下面是维修中心查询链接：

>

如果以上信息可以帮您解决问题，建议采纳，方便后来客户解决相同的问题。

如果问题没有得到解决，建议继续追问，我们收到以后会针对您的问题，继续帮您解答。

1、语法：必须比较熟悉，在写代码的时候，IDE(Integrated Development Environment，集成开发环境)的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误，并且知道任何修正。

2、命令：必须熟悉JDK(Java Development Kit，Java开发工具箱——JDK 是整个Java的核心，包括了Java运行环境，Java工具和Java基础的类库。JDK是学好Java的第一步。)带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、HtmlConverter、jar、 java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。

3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。

4、API（Application Programming Interface，应用程序编程接口）：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：

◆javalang包下的80%以上的类的功能的灵活运用；

◆javautil包下的80%以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer；

◆javaio包下的60%以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合；

◆javamath包下的100%的内容；

◆javanet包下的60%以上的内容，对各个类的功能比较熟悉；

◆javatext包下的60%以上的内容，特别是各种格式化类；

◆熟练运用JDBC 80%、javasecurity包下40%以上的内容，如果对于安全没有接触的话根本就不可能掌握java；

◆AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印；

◆Swing的基本内容，和AWT的要求类似；

◆XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

5、测试：Junit测试是程序员测试，即所谓白盒测试。一位合格的Java开发工程师必须熟悉使用junit编写测试用例完成代码的自动测试。

6、管理：必须熟悉使用Ant（中文译为蚂蚁，是一种基于Java的build工具。）完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。

7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。

8、思想：必须掌握OOP（Object Oriented Programming，面向对象编程）的主要要求，这样使用Java开发的系统才能是真正的Java系统。

9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。

10、博学：掌握J2EE 、Oracle 、WebLogic、Jboss、Spring、Struts、Hibernate 等流行技术，掌握软件架构设计思想、搜索引擎优化、缓存系统设计、网站负载均衡、系统性能调优等实用技术。

修改查询

@Modifying

@Query("update User u set ufirstname = 1 where ulastname = 2")

int setFixedFirstnameFor(String firstname, String lastname);

使用 Sort 和 JpaSort

public interface UserRepository extends JpaRepository {

  @Query("select u from User u where ulastname like 1%")

  List findByAndSort(String lastname, Sort sort);

  @Query("select uid, LENGTH(ufirstname) as fn_len from User u where ulastname like 1%")

  List findByAsArrayAndSort(String lastname, Sort sort);

}

repofindByAndSort("lannister", new Sort("firstname"));           

repofindByAndSort("stark", new Sort("LENGTH(firstname)"));       

repofindByAndSort("targaryen", JpaSortunsafe("LENGTH(firstname)"));

repofindByAsArrayAndSort("bolton", new Sort("fn_len"));   

使用已命名参数

public interface UserRepository extends JpaRepository {

  @Query("select u from User u where ufirstname = :firstname or ulastname = :lastname")

  User findByLastnameOrFirstname(@Param("lastname") String lastname,

                                @Param("firstname") String firstname);

}   

原生SQL分页

public interface UserRepository extends JpaRepository {

  @Query(value = "SELECT FROM USERS WHERE LASTNAME = 1",

    countQuery = "SELECT count() FROM USERS WHERE LASTNAME = 1",

    nativeQuery = true)

  Page findByLastname(String lastname, Pageable pageable);

}

Sort sort =newSort(SortDirectionDESC,"createTime");//创建时间降序排序Pageable pageable =newPageRequest(pageNumber,pageSize,sort);

使用原生SQL

public interface UserRepository extends JpaRepository {

  @Query(value = "SELECT FROM USERS WHERE EMAIL_ADDRESS = 1", nativeQuery = true)

  User findByEmailAddress(String emailAddress);

}

为了消除不确定性，可以在方法名内使用下划线“_”手动定义隔断点。

List findByAddress_ZipCode(ZipCode zipCode);

查询方法建立

distinct flag

ignoring case

order by

public interface PersonRepository extends Repository {

  List findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname);

  // Enables the distinct flag for the query  List findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname);

  List findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname);

  // Enabling ignoring case for an individual property  List findByLastnameIgnoreCase(String lastname);

  // Enabling ignoring case for all suitable properties  List findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname);

  // Enabling static ORDER BY for a query  List findByLastnameOrderByFirstnameAsc(String lastname);

  List findByLastnameOrderByFirstnameDesc(String lastname);

}

异步查询结果

@Async

Future findByFirstname(String firstname);           

@Async

CompletableFuture findOneByFirstname(String firstname);

@Async

ListenableFuture findOneByLastname(String lastname);

Like模糊查询

@Query(value = "select name,author,price from Book b where bname like %:name%")

List findByNameMatch(@Param("name") String name);

In 查询

@Query(value = "select from trade$seek_purchase_offer where sp_id in (:spIds) and of_enuu = :enUu", nativeQuery = true)

    List getSeekPurchaseOfferList(@Param("spIds") List spIds, @Param("enUu") Long enUu);

MappedSuperClass:

映射为非实体父类，该实体父类不会生成对应的数据表

@OneToOne

@Entity

@Table(name = "costume_all_id")

public class AllId extends AbstractEntity {

    private static final long serialVersionUID = 1L;

    @OneToOne(cascade = CascadeTypeALL)

    @JoinColumn(name = "costume_member_fk")

    private Member member;// 用户表外键

}

@OneToMany和@ManyToOne

@Entity

@Table(name = "costume_organization")

public class Organization extends AbstractEntity {

    private static final long serialVersionUID = 1L;

    @Column(nullable = false, length = 50)

    private String name; // 组织名称

    @OneToMany(mappedBy = "organization")

    private Set departmentSet; // 部门集合

}

@Entity

@Table(name = "costume_department")

public class Department extends AbstractEntity {

    private static final long serialVersionUID = 1L;

    @Column(nullable = false, length = 50)

    private String name; // 部门名称

    @ManyToOne(optional = false)

    private Organization organization; // 组织外键

    @ManyToMany

    private Set memberSet; // 用户表外键

    public Organization getOrganization() {

        return organization;

    }

    @JsonBackReference

    public void setOrganization(Organization organization) {

        thisorganization = organization;

    }

}

@ManyToMany

Entity

@Table(name = "costume_member")

public class Member extends AbstractEntity {

    private static final long serialVersionUID = 1L;

    @Column(nullable = false, length = 20)

    private String name;

    @ManyToMany

    @JoinTable(joinColumns = { @JoinColumn(name = "member_id") }, inverseJoinColumns = {

            @JoinColumn(name = "department_id") }) //被控方表字段名

    private Set departmentSet; // 部门表外键

    public Set getDepartmentSet() {

        return departmentSet;

    }

    @JsonBackReference

    public void setDepartmentSet(Set departmentSet)

    {

        thisdepartmentSet = departmentSet;

    }

}

HQL通过旅店名称查询旅店以及城市的所有信息 直接返回实体类

/

关联查询

@return

/

@Query(value = "select new perszpwdomainCityHohel(t1name AS cityName,t2name AS hotelName) from  TCity t1 left  join THotel t2 on t1id=t2city where t2name =:name")

List findCityAndHotelByHQLResultObj(@Param("name") String name);

@Data

public class CityHohel {

        private String cityName;

        private String hotelName;

        public CityHohel(String cityName, String hotelName) {

            thiscityName = cityName;

            thishotelName = hotelName;

        }

}

实例2

@Entity 

@Table(name="orders") 

public class Order { 

    private String orderid; 

    private Float amount = 0f; 

    private Set items = new HashSet(); 

    @Id 

    @Column(length = 12) 

    public String getOrderid() { 

        return orderid; 

    } 

    public void setOrderid(String orderid) { 

        thisorderid = orderid; 

    } 

    @Column(nullable = false) 

    public Float getAmount() { 

        return amount; 

    } 

    public void setAmount(Float amount) { 

        thisamount = amount; 

    } 

@OneToMany(cascade = { CascadeTypeREFRESH, CascadeTypePERSIST,CascadeTypeMERGE, CascadeTypeREMOVE },mappedBy ="order") //这里配置关系，并且确定关系维护端和被维护端。mappBy表示关系被维护端，只有关系端有权去更新外键。这里还有注意OneToMany默认的加载方式是赖加载。当看到设置关系中最后一个单词是Many，那么该加载默认为懒加载 

    public Set getItems() { 

        return items; 

    } 

    public void setItems(Set items) { 

        thisitems = items; 

    } 

        / 

          该方法用于向order中加order项 

          / 

    public void addOrderItem(OrderItem orderItem){ 

        orderItemsetOrder(this);//用关系维护端来维护关系 

        thisitemsadd(orderItem); 

    } 

}

@Entity 

public class OrderItem { 

    private Integer id; 

    private String productName; 

    private Float sellPrice = 0f; 

    private Order order; 

    @Id 

    @GeneratedValue 

    public Integer getId() { 

        return id; 

    } 

    public void setId(Integer id) { 

        thisid = id; 

    } 

    @Column(length = 40, nullable = false) 

    public String getProductName() { 

        return productName; 

    } 

    public void setProductName(String productName) { 

        thisproductName = productName; 

    } 

    @Column(nullable = false) 

    public Float getSellPrice() { 

        return sellPrice; 

    } 

    public void setSellPrice(Float sellPrice) { 

        thissellPrice = sellPrice; 

    } 

    @ManyToOne(cascade = {CascadeTypeMERGE,CascadeTypeREFRESH }, optional = true) 

    @JoinColumn(name="order_id")//这里设置JoinColum设置了外键的名字，并且orderItem是关系维护端 

    public Order getOrder() { 

        return order; 

    } 

    public void setOrder(Order order) { 

        thisorder = order; 

    } 

} 

缓存

    orgspringframeworkboot  

    spring-boot-starter-cache  

@Configuration  

@EnableCaching  

public class CacheConfig {  

}  

@Cacheable

Spring 在执行 @Cacheable 标注的方法前先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，执行该方法并将方法返回值放进缓存。

参数： value缓存名、 key缓存键值、 condition满足缓存条件、unless否决缓存条件

@Cacheable(value = "user", key = "#id")  

public User findById(final Long id) {  

    Systemoutprintln("cache miss, invoke find by id, id:" + id);  

    for (User user : users) {  

        if (usergetId()equals(id)) {  

            return user;  

        }  

    }  

    return null;  

}  

@CachePut

和 @Cacheable 类似，但会把方法的返回值放入缓存中, 主要用于数据新增和修改方法。

@CachePut(value = "user", key = "#userid")  

public User save(User user) {  

    usersadd(user);  

    return user;  

} 

@CacheEvict

方法执行成功后会从缓存中移除相应数据。

参数： value缓存名、 key缓存键值、 condition满足缓存条件、 unless否决缓存条件、 allEntries是否移除所有数据（设置为true时会移除所有缓存）

@CacheEvict(value = "user", key = "#userid") // 移除指定key的数据  

public User delete(User user) {  

    usersremove(user);  

    return user;  

}  

@CacheEvict(value = "user", allEntries = true) // 移除所有数据  

public void deleteAll() {  

    usersclear();  

}  

springcachetype=none 设置缓存无效化

集成EhCache

    netsfehcache  

    ehcache  

         xsi:noNamespaceSchemaLocation="ehcachexsd">  

src\main\resources/applicationproperties

springcacheehcacheconfig=classpath:ehcachexml

如果想自定义设置一些个性化参数时，通过Java Config形式配置。

@Configuration  

@EnableCaching  

public class CacheConfig {  

    @Bean  

    public CacheManager cacheManager() {  

        return new EhCacheCacheManager(ehCacheCacheManager()getObject());  

    }  

    @Bean  

    public EhCacheManagerFactoryBean ehCacheCacheManager() {  

        EhCacheManagerFactoryBean cmfb = new EhCacheManagerFactoryBean();  

        cmfbsetConfigLocation(new ClassPathResource("ehcachexml"));  

        cmfbsetShared(true);  

        return cmfb;  

    }  

}  

组合CacheManager

从多个CacheManager中轮询得到相应的Cache。

@Configuration  

@EnableCaching  

public class CacheConfig {  

    @Bean  

    public CacheManager compositeCacheManager(RedisTemplate redisTemplate) {  

        CompositeCacheManager cacheManager = new CompositeCacheManager(new ConcurrentMapCacheManager(), new SimpleCacheManager());  

        cacheManagersetFallbackToNoOpCache(false);  

        cacheManagerafterPropertiesSet();  

        return cacheManager;  

    }  

Option中有下面两个参数，分别定义否定应答和肯定应答在缓存中的生存周期：

max-ncache-ttl

为降低网络流量和提升服务器存储否定回答的性能。 max-ncache-ttl 以秒为单位设定这

些回答的保存时间默认max-ncache-ttl 是10800 秒(3 小时)。 max-ncache-ttl 不能超过7

天，如果设成一个更大的值，则将会被自动减为7 天。

max-cache-ttl

max-cache-ttl 设定了服务器储存普通(肯定)答案的最大时间。默认值一周(7 天)

下载中心有bind9的管理员手册，可以多参考一下

以上就是关于oracle数据库中in和exists的详细执行过程全部的内容，包括:oracle数据库中in和exists的详细执行过程、Memcached 在 Spring 里怎么用、如果网站很多用户来查询信息 怎么优化等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！