java面试重点（一）
个人学习总结，还望大家多多指教！
目 录
4、sessionFactory中获取session的方法--getCurrentSession（）和OpenSession（）区别：......... 6
6、Hibernate工作原理、六大核心编程接口（或对象，此接口非interface）：............................................. 8
1、******授权中的with admin option和with grant option区别：
oracle：
with admin option 只能在赋予 system privilege 的时使用
with grant option 只能在赋予 object privilege 的时使用
使用with admin option 被授权用户可将所获得的权限再次授予其它用户或角色，而且取消授权时不级联
使用with grant option 被授权用户可将所获得的权限再次授予其它用户或角色，并且取消权限是级联的
mysql：
mysql只有with grant option，对A用户进行的授权，A可以授予给其他用户，当收回对A的授权时，A授予给其他用户的权限不会级联收回。
注意：with grant option也可以被授予给其他用户。
2、日期转换
| package com.bors.test;
import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;
public class DateParserT {
/** * Date 与 String、long 的相互转换 * * @author bors * @param args */ public static void main(String[] args) {
Date dt = new Date(); System.out.println(dt); // 格式：Mon Jul 09 02:08:52 CST 2018
// 格式：2018-7-9 String formatDate = null; formatDate = DateFormat.getDateInstance().format(dt); System.out.println(formatDate);
// 格式：2018年7月9日 星期三 formatDate = DateFormat.getDateInstance(DateFormat.FULL).format(dt); System.out.println(formatDate);
// 格式 24小时制：2018-7-9 02:09:39 DateFormat dFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // HH表示24小时制； formatDate = dFormat.format(dt); System.out.println(formatDate);
// 格式12小时制：2018-7-9 02:09:39 DateFormat dFormat12 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); // hh表示12小时制； formatDate = dFormat12.format(dt); System.out.println(formatDate);
// 格式去掉分隔符24小时制：201879020939 DateFormat dFormat3 = new SimpleDateFormat("yyyyMMddHHmmss"); formatDate = dFormat3.format(dt); System.out.println(formatDate);
// 格式转成long型：1531073683 long lTime = dt.getTime() / 1000; System.out.println(lTime);
// 格式long型转成Date型，再转成String： 1464710394 -> ltime2*1000 -> 2016-05-31 23:59:54 long ltime2 = 1531073683; SimpleDateFormat lsdFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date lDate = new Date(ltime2 * 1000); String lStrDate = lsdFormat.format(lDate); System.out.println(lStrDate);
// 格式String型转成Date型：2018-07-09 02:09:56 -> Mon Jul 09 02:09:56 CST 2018 String strDate = "2018-07-09 02:09:56"; SimpleDateFormat lsdStrFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { Date strD = lsdStrFormat.parse(strDate); System.out.println(strD); } catch (ParseException e) { e.printStackTrace(); } } } |
3、delete from table与truncate table区别？
delete from table：
是属于DML,数据操作语言，是写入回滚段的，是需要提交或者回滚的，提交后才能生效。
delete 数据后，主键自增还是存在的
truncate table：
是属于DDL 数据定义语言，是不用提交，不用回滚，执行之后立即生效。是不写入回滚段的。
主键自增还是不存在的
--------------------------------------------
DML（data manipulation language）数据操纵语言：
就是我们最经常用到的 SELECT、UPDATE、INSERT、DELETE。 主要用来对数据库的数据进行一些操作,写入回滚段
DDL（data definition language）数据库定义语言：
在建表的时用到：CREATE、ALTER、DROP等。DDL主要是用在定义或改变表的结构，数据类型，表之间的链接和约束等初始化工作上，不写入回滚段
DCL（Data Control Language）数据库控制语言：
是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。这个比较少用到
---------------------
4、sessionFactory中获取session的方法--getCurrentSession（）和OpenSession（）区别：
hibernate3.0- 提供了一个方法openSession():Session，用于创建一个session对象
hibernate3.0+ 提供了一个新方法getCurrentSession():Session
用于获取上下文中的session对象，如果有则重用，不会新建;如果没有则自动新建。要求上下文中应该有事务。
当事务提交/回滚时自动关闭session，不需要手动关闭
------------------------------------------------------
*****getCurrentSession（）和OpenSession（）区别：
·采用getCurrentSession()创建的Session会绑定到当前的线程中去、而采用OpenSession()不会。
·采用getCurrentSession()创建的Session在commit或rollback后会自动关闭，采用OpenSession()必须手动关闭。
·采用getCurrentSession()需要在Hibernate.cfg.xml配置文件中加入如下配置：
<property name="current_session_context_class">thread</property>
5、Hibernate：5种查询方式 OID,ONG,HQL,QBC[JPA],NativeSQL[不建议]
1、ONG：对象导航查询
2、OID：按id查询 session.get(UserBean.class,id)/load(UserBean.class,id)
3.HQL:类sql的面向对象查询方法
Hql语句可以完全参照sql语句编写，其中列名称改为属性名，表名称改为实体类名称即可，所有语法基本和sql一致（除了动态sql查询）
Sql:select * from t_user;
Hql:select u from UserBean u; 简化写法： from UserBean;
Sql:select * from t_user where id>1;
Hql:select u from UserBean u where u.id>1;
Sql:select name,id from t_users where id>8;投影计算
Hql:select u.name,u.id from UserBean u where u.id>8; 返回object数组
select new Map(u.name,u.id) from UserBean u where u.id>8;返回map
Select new UserBean(u.name,u.id) from UserBean u where u.id>8;返回UserBean,但是必须有对应构造器，否则异常；
支持 模糊查 group by/ having /order by /
聚合函数sum count min max avg
4、QBC查询：使用Criteria对象
5、本地SQL查询：使用SQLQuery对象
6、Hibernate工作原理、六大核心编程接口（或对象，此接口非interface）：
1、首先，Configuration读取Hibernate的配置文件和映射文件中的信息，即加载配置文件和映射文件，并通过Hibernate配置文件生成一个多线程的SessionFactory对象；
2、然后，多线程SessionFactory对象生成一个线程Session对象；Session对象生成Query对象或者Transaction对象；可通过Session对象的get()，load()，save()，update()，delete()和saveOrUpdate( )等方法对PO进行加载、保存、更新、删除等操作；
3、在查询的情况下，可通过Session 对象生成一个Query对象，然后利用Query对象执行查询操作；如果没有异常，Transaction对象将提交这些操作结果到数据库中。
Hibernate六大核心编程接口：
1、Configuration类用于读取并解析xml文件，是SessionFactory的工厂，属于即用即丢型对象，生命周期在方法内部
2、SessionFactory接口是Session的工厂，属于重量级长生命周期对象[持有2级缓存]、线程安全，一般开发中针对一个数据源只创建一个SessionFactory。最佳的编程实践为单例模式
3、Session接口充当了实体管理的功能[save/update/delete/load/get],属于轻量级短生命周期对象[持有1级缓存]、线程不安全，最佳的编程实践为ThreadLocal或者方法体内
Session对象是Connection对象的浅封装,需要考虑使用try/finally结构保证及时关闭
4、Transaction接口充当事务管理器，封装了底层的事务实现。属于轻量级短生命周期对象、线程不安全，最佳的编程实践为ThreadLocal或者方法体内。
注意：Session对象<==--绑定--==>Transaction对象
- Criteria接口和Query接口用于实现复杂查询，属于轻量级短生命周期对象、线程不安全，最佳的编程实践为方法体内
--------------------------------------------------------
7、Hibernate使用load和get加载的区别:
--------------------------------------
1.相同点：load和get都是按id进行查询一个记录,调用方法一致
2.不同点：
2.1加载方式不同
load默认采用延迟加载的方式,所以load首先在缓存中查找数据，有则返回查找到的数据，如果没有则返回一个代理对象,当访问非主键属性时才真正执行sql查询(要求获取的session不能关闭，否则懒初始化异常org.hibernate.LazyInitializationException)。
get默认采用立即加载的方式，get执行时首先在缓存中查找数据，如果有则立即返回，不执行查询;如果没有则立即执行数据库sql查询操作.
2.2返回结果不同：
load方法在查询不到数据时会自动抛出org.hibernate.ObjectNotFoundException异常。
get方法查询不到数据时会返回null
----------------------------------------
8、*****MyBatis二级缓存与hibernate二级缓存区别
-----------------------------------------------------------------------
MyBatis一级缓存：
-默认存在。sqlSession级别的缓存。session内部维系了一个map。
--不能跨用户，也不能跨session。
map<KEY,VALUE>:
key:你当前的SQL和参数
value:查询的结果
在当前session中，每次查询的时候，都先扫描map中是否有对应的Key,
如果有，直接返回value,如何没有，才查询数据库。
session的销毁，也会销毁map。
clearCache();
session.close();
MyBatis二级缓存：
必须手工配置，SqlSessionFactory级别的缓存，内部也有一个map。
能跨用户，能够跨session。
map<KEY,VALUE>:
key:你当前的SQL和参数
value:查询的结果
在当前session中，每次查询的时候，都先扫描map中是否有对应的Key,
如果有，直接返回value,如何没有，才查询数据库。
二级缓存的配置：
<cache></cache>
什么时候用二级缓存，什么时候不用二级缓存？
不用：
1：关键性的金融性数据，是不用二级缓存的。
工资表
2：私有，非共享性数据，是不使用二级缓存。
Userinfo
用：
3：公共的，共享的，非关键性数据，使用二级缓存、
数据字典表 民族 国家 省市区 类型
-------------------------------------------------------------------------------------------
****** Hibernate的缓存[重点]
缓存是位于应用程序和永久性数据存储源之间用于临时存放复制数据的内存区域，缓存可以降低应用程序之间读写永久性数据存储源的次数，从而提高应用程序的运行性能；
hibernate的缓存大致可以分为两级：一级缓存【由session进行管理】 二级缓存【由SessionFactory进行管理】和查询缓存【基于二级缓存】
hibernate在查询数据时，首先会到缓存中查找，如果找到就直接使用，找不到时才从永久性数据存储源中检索，因此，把频繁使用的数据加载到缓存中，可以减少应用程序对永久性数据存储源的访问，使应用程序的运行性能得以提升；
一级缓存是Session级别的缓存，它属于事务范围的缓存，该级缓存由hibernate管理，应用程序无需干预Hibernate的一级缓存由Session提供，只存在于Session的生命周期中，当应用程序调用Session接口的save(),update(),saveOrupDate(),get(),load()或者Query和Criteria实例的list(),iterate()等方法时，如果Session缓存中没有相应的对象，hibernate就会把对象加入到一级缓存中，当session关闭时，该Session所管理的一级缓存也会立即被清除；
get/load方法读写缓存
list方法会写缓存但是不读缓存
iterate方法会读写缓存
Iterator<CatalogBean> it1 = session.createQuery("from CatalogBean").iterate();
1、发送查询，查询满足条件的id值;不像list()方法直接获取的是对象。这里实际上采用的是延迟加载的方式。
2、当访问iterate()返回的代理对象时，才发送按照id的查询，获取具体的对象
引发1+N问题：
例如查询3个不同的对象，则iterate发送了4条查询语句，第一条是查询id，后面则是按照id查询对应的数据
多数在具体使用中一般不建议使用iterate，但是由于iterate方法可以读写缓存，如果可以确定数据已经查询过了，则使用iterate比list效率高
前面还讲过一个1+N问题 OGN
from UserBean --当访问role属性时hibernate按照默认配置<many-to-one>中的fetch=select发送对应的select语句加载对应的role属性
针对load/get的解决方法
fetch改为join
解决方案使用迫切左外链接查询
form UserBean u left join fetch u.role
Session接口为应用程序提供了两个管理缓存的方法：
evict(obj)方法：用于将某个对象obj从Session的一级缓存中清除
clear()方法：用于将一级缓存中的所有对象全部清楚
缓存引发的问题：批量数据处理
方案1：使用HQL中的delete和update语句,这里没有insert
Query query = session.createQuery("update CatalogBean c set c.memo=?0 where c.id>?1");
query.setString(0, "新数据1");
query.setLong(1, 1L);
int len=query.executeUpdate();
session.createQuery("delete CatalogBean c where c.id>:id").setLong("id",1L).executeUpdate();
方法2：绕过hibernate而直接使用JDBC
方法3：使用StatelessSession ss=sessionFactory.openStatelessSession();
----------------------------
二级缓存是一个可插拔的缓存插件，它是由SessionFactory负责管理的；
由于SessionFactory对象的生命周期与应用程序的整个过程对应，通常一个应用程序对应一个SessionFactory，因此，二级缓存是进程范围或者集群范围的缓存；
与一级缓存一样，二级缓存也是根据对象的id来加载与缓存，当执行某个查询获得结果集为实体对象集时，hibernate就会把它们按照对象id加载到二级缓存中，在访问指定的id的对象时，首先从一级缓存中查找，找到就直接使用，找不到则转到二级缓存中查找(必须配置且启用二级缓存)，如果二级缓存中找到，则直接使用，否则会查询数据库，并将查询结果根据对象的id放到缓存中；
Hibernate的二级缓存功能是通过配置二级缓存插件来实现的，常用的二级缓存插件包括EHCache，OSCache，SwarmCache和JBossCache。其中EHCache缓存插件是理想的进程范围的缓存实现
如何配置ehcache缓存
1、添加依赖
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>5.3.2.Final</version>
</dependency>
2、创建EHCache的核心配置文件ehcache.xml
<ehcache>
<diskStore path="java.io.tmpdir"/>设置缓存数据文件的存储目录
<defaultCache 默认设置缓存的默认数据过期策略
maxElementsInMemory="10000" 设置缓存对象的最大数目
eternal="false" 指定是否永不过期，true为不过期，false为过期
timeToIdleSeconds="120" 设置对象处于空闲状态的最大秒数
timeToLiveSeconds="120" 设置对象处于缓存状态的最大秒数
overflowToDisk="true" 设置内存溢出时是否将溢出对象写入硬盘
/>
<cache name="sampleCache1" 设置具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域，命名缓存机制允许用户在每个类以及类的每个集合的粒度上设置数据过期策略
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="true"
/>
</ehcache>
3、在hibernate.cfg.xml配置文件中，启用EHCache的配置
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 设置二级缓存插件EHCache的Provider类 -->
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
4、在实体类的映射中声明并发访问策略
xml配置:
<cache usage="read-write"/>
usage属性取值为read-only时表示只读型并发访问策略；
read-write表示读写型并发访问策略；
nonstrict-read-write表示非严格读写型并发访问策略；
EHCache插件不支持transactional(事务型并发访问策略)
注解配置：
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
---------什么时候使用二级缓存?
经常查询但很少修改的数据
数据量在可接受的范围内
不会被第三方修改
非敏感数据
查询缓存： 按照查询条件存储查询结果，需要基于二级缓存
在hibernate.cfg.xml中配置启用查询缓存
<property name="hibernate.cache.use_query_cache">true</property>
在查询中使用查询缓存
Query query = sess2.createQuery("from Student");
query.setCacheable(true);
List<Student> student = query.list();
只有在查询一致的情况下（查询条件一致），而且需要频繁查询时使用
-----------------------------------------------------------------------------------------
9、java中10大常见异常：
java.lang.NullPointerException
程序遇上了空指针 ，简单地说就是调用了未经初始化的对象或者是不存在的对象
java.lang.ClassNotFoundException
指定的类不存在，这里主要考虑类的名称和路径是否正确即可
java.lang.ArrayIndexOutOfBoundsException
数组下标越界
java.lang.IndexOutOfBoundsException
索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
java.lang.NoSuchMethodException
方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。
java.lang.NumberFormatException
数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
java.lang.ArithmeticException
数学运算异常 ，比如程序中出现(1/0)除以零这样的运算就会出这样的异常
java.lang.InstantiationError
实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常。
java.sql.SQLException
Sql语句执行异常
java.io.IOException
输入输出异常
java.lang.IllegalArgumentException
方法参数错误
java.lang.IllegalAccessException
无访问权限异常
*****·MyBatis三大核心对象
三大对象：
1、SqlSessionFactoryBuilder：负责构建SqlSessionFactory，并且提供了多个build()方法的重载
2、SqlSessionFactory：创建SqlSession实例的工厂
3、SqlSession：用于执行持久化操作的对象
三大对象获取的步骤：
（1）每个MyBatis的应用程序都以一个SqlSessionFactory对象的实例为核心。
（2）首先获取SqlSessionFactoryBuilder对象，可以根据XML配置文件的实例构建该对象。
（3）然后获取SqlSessionFactory对象，该对象实例可以通过SqlSessionFactoryBuilder对象来获得。
（4）有了SqlSessionFactory对象之后，通过SqlSessionFactory对象的openSession()方法就可以获取SqlSession实例，SqlSession对象中完全包含以数据库为背景的所有执行SQL操作的方法。
三大对象的声明周期和作用域：
《1》SqlSessionFactoryBuilder的最大特点是：用过即丢。一旦创建了SqlSessionFactoryBuilder对象之后，这个类就不再需要存在了，因此SqlSessionFactoryBuilder的最佳范围是存在方法体内，也就是局部变量而已。
《2》SqlSessionFactory对象一旦创建，就会在整个应用运行过程中始终存在，因此SqlSessionFactory的最佳作用域是Application（单例模式）。
《3》SqlSession对应着一次数据库回话。在每次访问数据库时都需要创建它，每个线程都有自己的SqlSession实例，SqlSession实例不能被共享，也不是线程安全的。因此最佳的作用域范围是request作用域或者方法体作用域内。
10、Mybatis 三剑客：
Mybatis generator反向映射、
Mybatis pagehelper分页、
Mybatis plugin跳转提示
10.1 Mybatis ${}与#{}区别
#{}是预编译处理，${}是字符串替换。
Mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值；
Mybatis在处理${}时，就是把${}替换成变量的值。
使用#{}可以有效的防止SQL注入，提高系统安全性。
------------------------------------------------------------------------------------
11、mybatis与hibernate的区别、应用场景：
hibernate和mybatis是当前流行的ORM框架。
----------------
相同点：
1.Hibernate与MyBatis都是通过SessionFactoryBuider由XML配置文件生成SessionFactory，由SessionFactory 生成Session，由Session来开启执行事务和SQL语句（CRUD）。
2.Hibernate和MyBatis都支持JDBC数据库连接（Java DataBase Connectivity）和JTA事务处理（Java Transaction API，Java事务API）。
注：jdbc和jta的主要作用是增强数据访问能力。
3.基于ORM（Object Relational Mapping， 对象关系映射）思想解决了entity和数据库的映射问题。
不同点：
1.sql方面：mybaits通过mapper.xml维护映射结果，程序员手动编写sql相比hibernate自动生成hql（hibernate sql）更加灵活，sql调优更加容易（hibernate因为更好的封装性，开发效率提高的同时，sql语句调优要更费力，当然可以手动修改sql来优化，但是同时也会影响开发效率）；hibernate的hql数据库移植性更好，体现在强壮性。hibernate在级联删除的时候效率低；数据量大， 表多的时候，基于关系操作会变得复杂。
2.缓存方面：mybatis和hibernate都可以使用第三方缓存，而hibernate相比maybatis有更好的二级缓存机制
----------------------------------------------------------------
区别 Mybatis Hibernate
----------------------------------------------------------------
市场占有率： 高 低
适合的行业： 互联网 电商 项目 传统的(ERP CRM OA)
性能： 高 低
Sql灵活性： 高 低
门槛： 低 高
Sql配置文件： 多（维护麻烦） 低
ORM： 半自动化 完全自动化
数据库无关性： 低 高
----------------------------------------------------------------
Hibernate应用场景：需求变化不多的中小型项目中，比如后台管理，ERP\ORM\OA;
Mybatis 应用场景： 需求变化较多的项目，比如：互联网项目。
-======================================================================================
12、mysql中concat 和 group_concat()的用法
------------------------------------------------------------------------------------------------------
一、CONCAT（）函数
CONCAT（）函数用于将多个字符串连接成一个字符串。
使用数据表Info作为示例，其中SELECT id,name FROM info LIMIT 1;的返回结果为
+----+--------+
| id | name |
+----+--------+
| 1 | BioCyc |
+----+--------+
1、语法及使用特点：
CONCAT(str1,str2,…)
返回结果为连接参数产生的字符串。如有任何一个参数为NULL ，则返回值为 NULL。可以有一个或多个参数。
2、使用示例：
SELECT CONCAT(id, ‘，’, name) AS con FROM info LIMIT 1;返回结果为
+----------+
| con |
+----------+
| 1,BioCyc |
+----------+
SELECT CONCAT(‘My’, NULL, ‘QL’);返回结果为
+--------------------------+
| CONCAT('My', NULL, 'QL') |
+--------------------------+
| NULL |
+--------------------------+
3、如何指定参数之间的分隔符
使用函数CONCAT_WS（）。使用语法为：CONCAT_WS(separator,str1,str2,…)
CONCAT_WS() 代表 CONCAT With Separator ，是CONCAT()的特殊形式。第一个参数是其它参数的分隔符。分隔符的位置放在要连接的两个字符串之间。分隔符可以是一个字符串，也可以是其它参数。如果分隔符为 NULL，则结果为 NULL。函数会忽略任何分隔符参数后的 NULL 值。但是CONCAT_WS()不会忽略任何空字符串。 (然而会忽略所有的 NULL）。
如SELECT CONCAT_WS('_',id,name) AS con_ws FROM info LIMIT 1;返回结果为
+----------+
| con_ws |
+----------+
| 1_BioCyc |
+----------+
SELECT CONCAT_WS(',','First name',NULL,'Last Name');返回结果为
+----------------------------------------------+
| CONCAT_WS(',','First name',NULL,'Last Name') |
+----------------------------------------------+
| First name,Last Name |
+----------------------------------------------+
----------------------------------------------------------------------------------------------------------------------
二、GROUP_CONCAT（）函数
GROUP_CONCAT函数返回一个字符串结果，该结果由分组中的值连接组合而成。
使用表info作为示例，其中语句SELECT locus,id,journal FROM info WHERE locus IN('AB086827','AF040764');的返回结果为
+----------+----+--------------------------+
| locus | id | journal |
+----------+----+--------------------------+
| AB086827 | 1 | Unpublished |
| AB086827 | 2 | Submitted (20-JUN-2002) |
| AF040764 | 23 | Unpublished |
| AF040764 | 24 | Submitted (31-DEC-1997) |
+----------+----+--------------------------+
1、使用语法及特点：
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] [,col ...]]
[SEPARATOR str_val])
在 MySQL 中，你可以得到表达式结合体的连结值。通过使用 DISTINCT 可以排除重复值。如果希望对结果中的值进行排序，可以使用 ORDER BY 子句。
SEPARATOR 是一个字符串值，它被用于插入到结果值中。缺省为一个逗号 (",")，可以通过指定 SEPARATOR "" 完全地移除这个分隔符。
可以通过变量 group_concat_max_len 设置一个最大的长度。在运行时执行的句法如下： SET [SESSION | GLOBAL] group_concat_max_len = unsigned_integer;
如果最大长度被设置，结果值被剪切到这个最大长度。如果分组的字符过长，可以对系统参数进行设置：SET @@global.group_concat_max_len=40000;
2、使用示例：
语句 SELECT locus,GROUP_CONCAT(id) FROM info WHERE locus IN('AB086827','AF040764') GROUP BY locus; 的返回结果为
+----------+------------------+
| locus | GROUP_CONCAT(id) |
+----------+------------------+
| AB086827 | 1,2 |
| AF040764 | 23,24 |
+----------+------------------+
语句 SELECT locus,GROUP_CONCAT(distinct id ORDER BY id DESC SEPARATOR '_') FROM info WHERE locus IN('AB086827','AF040764') GROUP BY locus;
返回结果为：
+----------+----------------------------------------------------------+
| locus | GROUP_CONCAT(distinct id ORDER BY id DESC SEPARATOR '_') |
+----------+----------------------------------------------------------+
| AB086827 | 2_1 |
| AF040764 | 24_23 |
+----------+----------------------------------------------------------+
语句SELECT locus,GROUP_CONCAT(concat_ws(', ',id,journal) ORDER BY id DESC SEPARATOR '. ') FROM info WHERE locus IN('AB086827','AF040764') GROUP BY locus;
返回结果为：
+----------+--------------------------------------------------------------------------+
| locus | GROUP_CONCAT(concat_ws(', ',id,journal) ORDER BY id DESC SEPARATOR '. ') |
+----------+--------------------------------------------------------------------------+
| AB086827 | 2, Submitted (20-JUN-2002). 1, Unpublished |
| AF040764 | 24, Submitted (31-DEC-1997) . 23, Unpublished |
+----------+--------------------------------------------------------------------------+
13、oracle和mysql的区别?
1，分页： oracle分页，要用到rownum属性，三段式分页；在mysql中分页使用limit。
2，主键自增： mysql表的主键自增用auto_increment；oracle建表时，没有auto_increment，表主键字段自增要自己添加序列，插入时，把序列的值，插入进去。
3，dual表： oracle有一个dual表，当select后没有表时，加上的。不加会报错的。select 1 这个在mysql不会报错的，oracle下报错。select 1 from dual这样的话，oracle就不会报错了。
4，空值判断： name != "" 这样在mysql下不会报错，但是oracle会报错。在oracle下的要换成name is not null
5，引号： oracle下对单引号，双引号要求的很死，一般不准用双引号，用了会报
ERROR at line 1:
ORA-00904: "t": invalid identifier
而MySQL要求就没有那么严格了，单引号，双引号都可以。
6，数据转换： oracle有to_number,to_date转换函数，oracle表字段是number型，如果你$_POST得到的参数是123456，入库的时候，需要to_number来强制转换一下，不然会被当成字符串来处理。而mysql却不会。（$_POST 变量用于收集来自 method=”post” 表单的值）
7，MySQL有group_concat函数，oracle没有。
8，用户权限管理：mysql的用户权限管理，是在mysql自带的一个数据库mysql里面，而oracle是用户权限是根着表空间走的。
9，group by： 在下oracle下用group by，group by后面的字段必须在select后面出现，否则报错，而mysql不会。
10，引擎: mysql存储引擎有好多，常用的MyISAM,Innodb等，oracle中不存在引擎的概念，数据处理大致可以分成两大类：联机事务
处理OLTP（on-line transaction processing）、联机分析处理OLAP（On-Line Analytical Processing）。
11，字段位置: oracle字段无法选择位置，alter table add column before|after，这样会报错的，即使你用sql*plus这样的工具，也没法改字段的位置。
12，字段类型: oracle的表字段类型也没有mysql多，并且有很多不同，例如：mysql的int,float合成了oracle的number型等。
13，查询+as: oracle查询时from 表名后面不能加as,否则报错，select t.username from test as t 在mysql下可以。
14，字符串截取：mysql中是substring函数，oracle是substr函数。
什么是Spring？
IOC容器（控制反转）：负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
IOC底层原理：spring启动时，容器开始初始化时，会先把所有bean实例化，之后把实例化的对象放到一个大的map对象里面去，下次使用的时候直接从map里面get获取就好，就可以实现自动装配。
AOP:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.
14、*****Spring AOP 应用(在哪里用过AOP？AOP 好在哪里？)
-----------------------------------------
在哪里用过AOP？
1】在Spring项目中，事务用到了AOP，用的是注解式事务；
2】在权限判断中用到了AOP，用切面切入整个项目的Action层，用RequestContextHolder获得request对象，然后用request对象获得当前用户登录信息info，再取得当前用户所能访问的权限树列表role，同时取得当前用户请求的地址，查看地址是否在用户登录后的树列表tree中，从而判断用户的方法权限；
3】用AOP写整个项目的行为日志，（谁--什么时间--干了什么）：
首先AOP切入整个项目BIZ层，用的是环绕通知around
第一、先用SimpleDateFormat获得系统当前时间；String time = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date());
第二、用RequestContextHolder获得request对象，用request对象获得session中的当前用户；Userinfo info = (Userinfo)request.getSession().getAttribute("info");
第三、然后用 request.getRemoteHost()获得对方ip； String ip = request.getRemoteHost();
第四，获得行为，用Annotation注解的形式，在每个BIZ方法上描述当前方法的行为，然后在AOP的注解类中取得当前的方法名称，从而根据方法取得其注解即当前操作行为
从而完成整个项目的日志，who when where do what
AOP 好在哪里？
如果没有Aop，那么每个BIZ的方法都得写需要添加的代码，代码量太大，且不利于日后修改；
有了Spring AOP，即使所有代码写完了，我们可以用AOP直接切到整个biz层，执行这个代码。
------------------------------------------------------------------------------------
15、Spring mvc流程图
User----DispactherServlet----HandlerMapper----HandlerAdapter----Handler/controller
----ViewResolver----View----DispactherServlet----User
- 用户发起请求到前端控制器（DispatcherServlet），该控制器会过滤出哪些请求可以访问Servlet、哪些不能访问。就是url-pattern的作用，并且会加载springmvc.xml配置文件。
- 前端控制器会找到处理器映射器（HandlerMapping），通过HandlerMapping完成url到controller映射的组件，简单来说，就是将在springmvc.xml中配置的或者注解的url与对应的处理类找到并进行存储，用map<url,handler>这样的方式来存储。
- HandlerMapping有了映射关系，并且找到url对应的处理器，HandlerMapping就会将其处理器（Handler）返回，在返回前，会加上很多拦截器。
- DispatcherServlet拿到Handler后，找到HandlerAdapter（处理器适配器），通过它来访问处理器，并执行处理器。
- 执行处理器
- 处理器会返回一个ModelAndView对象给HandlerAdapter
- 通过HandlerAdapter将ModelAndView对象返回给前端控制器(DispatcherServlet)
- 前端控制器请求视图解析器(ViewResolver)去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)，其实就是将ModelAndView对象中存放视图的名称进行查找，找到对应的页面形成视图对象
- 返回视图对象到前端控制器。
- 视图渲染，就是将ModelAndView对象中的数据放到request域中，用来让页面加载数据的。
- 通过第8步，通过名称找到了对应的页面，通过第10步，request域中有了所需要的数据，那么就能够进行视图渲染了。最后将其返回即可。
Adapter适配器相当于充电器/水管三通,便于切换实现功能。
------------------------------------------------------------------------------
16、Spring 、SpringMVC 、Struts2之间的区别？
=====================================================================================================
一、Spring与SpringMVC的区别：
spring是一个开源框架，是为了解决企业应用程序开发
--------------------------------------------
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
范围：任何Java应用 Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架。
1、轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外， Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
2、IOC控制反转——Spring通过一种称作控制反转（IOC）的技术促进了低耦合。当应用了IOC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IOC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。【IOC控制反转：IOC 容器负责实例化、定位、配置应用中程序中的对象，及创建这些对象之间的依赖】
3、AOP面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 【AOP面向切面编程，是通过预编译和运行期动态代理实现程序功能的统一维护的一种技术】
4、容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的， 难以使用。
5、框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。Spring的两大核心AOP与IOC，可以单独用于任何应用，包括与Struts等MVC框架与Hibernate等ORM框架的集成，目前很多公司所谓的轻量级开发就是用Spring + Struts2 + Hibernate。
------------------------------------------------------
Spring MVC就是一个MVC框架，Spring MVC annotation式的开发比Struts2方便，可以直接代替上面的Struts（当然Struts的做为一个非常熟的MVC，功能上感觉还是比Spring强一点，不过Spring MVC已经足够用了）。当然spring mvc的执行效率比struts高，是因为struts的值栈影响效率。
spring mvc类似于struts的一个MVC开框架，其实都是属于spring，spring mvc需要有spring的架包作为支撑才能跑起来。
==============================================================================================================
二、Spring与Struts2的区别：
Struts2就是一个拦截器栈 也就是一系列的拦截器。处理用户的请求，OGNL的使用，表单验证 等都是默认的拦截器在起作用。
spring的拦截器，主要体现在AOP的事务管理方面，还有比如一些错误或者异常的日志的显示也是通过配置spring的log拦截器来实现的。
==============================================================================================================
三、StringMVC与Struts2的区别：
1、Struts2是类级别的拦截，一个类对应一个request上下文，SpringMVC是方法级别的拦截,一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现 restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。
2、SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的,但其所有Action变量是共享的，这不会影响程序运行，却给我们编码 读程序时带来麻烦， 每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
3、Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map,供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。
4、拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。
5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。
6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。
7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。
8、SpringMVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。
9、设计思想上，Struts2更加符合OOP的编程思想，SpringMVC就比较谨慎,在servlet上扩展。
10、SpringMVC开发效率和性能高于Struts2。
11、SpringMVC可以认为已经100%零配置。
---------------------------------------------------------
17、Spring框架分为哪七大模块？
C C D O A W M
1. Spring Core：
Core封装包是框架的最基础部分，提供IOC和DI依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。
2.Spring Context:
构建于Core封装包基础上的 Context封装包，提供了一种框架式的对象访问方法，有些象JNDI注册器。Context封装包的特性得自于Beans封装包，并添加了对国际化（I18N）的支持（例如资源绑定），事件传播，资源装载的方式和Context的透明创建，比如说通过Servlet容器。
3．Spring DAO:
DAO (Data Access Object)提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。 并且，JDBC封装包还提供了一种比编程性更好的声明性事务管理方法，不仅仅是实现了特定接口，而且对所有的POJOs（plain old Java objects）都适用。
4.Spring ORM:
ORM 封装包提供了常用的“对象/关系”映射APIs的集成层。 其中包括JPA、JDO、hibernate 和 MyBatis 。利用ORM封装包，可以混合使用有spring提供的特性进行“对象/关系”映射，如前边提到的简单声明性事务管理。
5.Spring AOP:
Spring的 AOP 封装包提供了符合AOP Alliance规范的面向方面的编程实现，让你可以定义，例如方法拦截器（method-interceptors）和切点（pointcuts），从逻辑上讲，从而减弱代码的功能耦合，清晰的被分离开。而且，利用source-level的元数据功能，还可以将各种行为信息合并到你的代码中。
6.Spring Web:
Spring中的 Web 包提供了基础的针对Web开发的集成特性，例如多方文件上传，利用Servlet listeners进行IOC容器初始化和针对Web的ApplicationContext。当与WebWork或Struts一起使用Spring时，这个包使Spring可与其他框架结合。
7.Spring Web MVC:
Spring中的MVC封装包提供了Web应用的Model-View-Controller（MVC）实现。Spring的MVC框架并不是仅仅提供一种传统的实现，它提供了一种清晰的分离模型，在领域模型代码和Web Form之间。并且，还可以借助Spring框架的其他特性。
------------------------------------------------------
18、Struts2（拦截器）工作流程：
1：jsp首先提交请求给StrutsPrepareAndExecuteFilter
2：Filter会自动加载struts.xml文件。
3：完成struts.xml文件中各种Action和地址的映射。
4：通过struts2的拦截器栈*****。
5：各种拦截器的栈，帮助你完成各种各样的功能。
6：再来调用你要调用的Action.
7: 再回到你的拦截器中最后回到过滤器中。
--------------------------
19、Struts2-ActionSupport的五大常量：S-N-E-I-L
Struts2最主要是2个映射：
请求的命令《===》类的映射
返回的结果《===》转发的视图的映射
com.opensymphony.xwork2.ActionSupport定义的五个常量:
Static String SUCCESS Action执行成功。显示结果视图
Static String NONE Action执行成功，但是不会显示一个视图。通常产生这种情况的原因是被其他视图重定向了。
Static String ERROR Action执行失败。显示一个错误的视图（页面），要求用户再次输入相关数据。
Static String INPUT Action的执行成功需要更多的输入。这个结果是一个典型的结果，它表明如果一个表单通过提供默认的表单来操作一个Action。这个表单会显示给最终用户。
也用于用户输入无效，意味着用户需要再次输入
Static String LOGIN Action不能执行，因为用户没有登录。已登录的画面会被关闭。
==============================================================
struts.XML配置：
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- struts2的action必须放在一个指定的包空间下定义 -->
<package name="default" extends="struts-default">
<!-- 定义处理请求URL为login.action的Action -->
<action name="login" class="com.wang.action.LoginAction">
<!-- 定义处理结果字符串和资源之间的映射关系 -->
<result name="success">/success.jsp</result>
<result name="error">/error.jsp</result>
</action>
</package>
</struts>
-----------------------------------------------------------
20、*****拦截器与过滤器的区别 ：
1、拦截器是基于java的反射机制的，而过滤器是基于函数回调。
2、拦截器不依赖servlet容器，过滤器依赖servlet容器。
3、拦截器只对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
4、拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
5、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次
6、执行顺序 ：过滤前 - 拦截前 - Action处理 - 拦截后 - 过滤后。
=================================================================================
21.视图view与实表的区别与联系
-----------
区别：
1】视图是已经编译好的sql语句。而表不是
2】视图没有实际的物理记录。而表有
3】表是内容，视图是窗口
4】表只用物理空间而视图不占用物理空间，视图只是逻辑概念的存在，表可以及时对它进行修改，但视图只能用创建的语句来修改
5】表是内模式，视图是外模式
6】视图是查看数据表的一种方法，可以查询数据表中某些字段构成的数据，只是一些SQL语句的集合。从安全的角度说，视图不让用户接触数据表，从而不知道表结构。
7】表属于全局模式中的表，是实表；视图属于局部模式的表，是虚表。
8】视图的建立和删除只影响视图本身，不影响对应的基表。
-----------
联系：
视图（view）是在基表之上建立的表，它的结构（即所定义的列）和内容（即所有数据行）都来自基本表，它依据基表存在而存在。一个视图可以对应一个基本表，也可以对应多个基本表。视图是基表的抽象和在逻辑意义上建立的新关系。
==================================================================================
22. MySQL引擎MyISAM和Innodb的区别?
MyISAM引擎
MyISAM：是MySQL默认的引擎，没有提供对数据库事务的支持，不支持行级锁和外键，因此当INSERT或UPDATE数据时（即写操作）需要锁定整个表，效率便会低一些。不过和Innodb不同，MyISAM中存储了表的行数，于是SELECT COUNT(*) FROM TABLE时只需要直接读取已经保存好的值而不需要进行全表扫描。如果表的读操作远远多于写操作且不需要数据库事务的支持，那么MyISAM也是很好的选择。
Innodb引擎
Innodb：引擎提供了对数据库ACID事务的支持，实现了SQL标准的四种隔离级别。还提供了行级锁和外键约束，它的设计目标是处理大容量数据库系统，它本身其实就是基于MySQL后台的完整数据库系统，MySQL运行时Innodb会在内存中建立缓冲池，用于缓冲数据和索引。但是该引擎不支持FULLTEXT类型的索引，而且它没有保存表的行数，当SELECT COUNT(*) FROM TABLE时需要扫描全表。当需要使用数据库事务时，该引擎当然是首选。由于锁的粒度更小，写操作不会锁定全表，所以在并发较高时，使用Innodb引擎会提升效率。但是使用行级锁也不是绝对的，如果在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表。
主要区别：
1、MyISAM是不支持事务、非事务安全的，而InnoDB支持事务、是事务安全的
2、MyISAM锁的粒度是表级的，而InnoDB支持行级锁
3、MyISAM支持全文类型索引，而InnoDB不支持全文索引
4、MyISAM相对简单，执行效率上要优于InnoDB，小型应用可以考虑使用MyISAM
5、MyIASM表保存成文件形式，跨平台使用更加方便
应用场景：
1、MyISAM管理非事务表，提供高速存储和检索以及全文搜索能力，如果在应用中执行大量select操作，应该选择MyISAM
2、InnoDB用于事务处理，具有ACID事务支持等特性，如果在应用中执行大量insert和update操作，应该选择InnoDB
======================================================================================
23.MySQL左连接、内连接、右连接
左外连接：left join------左表数据全部显示在查询结果集中，如果右表中没有对应数据，那么右表字段显示null
右外连接：right join------右表数据全部显示在查询结果集中，如果表中没有对应数据，那么左表字段显示null
内 连 接: inner join------显示满足条件的两表的公共部分
========================================================================================
24.mysql聚合函数 sum count avg max min
count(): 求表中数据的总记录数
sum(): 求表中某一字段值的总和
avg(): 求表中某一字段值的均值
max(): 求表中某一字段值的最大值
min(): 求表中某一字段值的最小值
=======================================================================================
25. 前端获得表单元素值
<form name="myform">
<input type="text" value="123" name="name1" id="id1" />
<input type="text" value="000" name="name2" id="id2" />
</form>
-1- document.getElementById("id1").value 根据form表单里input元素的id属性值获取
-2- document.forms[0].name1.value 根据form表单里input元素的name属性值获取第一个表单form[0]的name属性的值
-3- document.myform.name1.value 获取名字为myform的表单的input元素名为name1的值
-4- document.forms[0].elements[1].value 获取第一个表单forms[0]的第一个元素elements[1]的值
-5- document.myform.elements[1].value 获取名字为myform的表单的第一个元素的值
===================================================================
26.面向对象
--思想特点：
封装：
·对外隐藏复杂，暴露简单的使用方法；
·提高代码重用性；
·隔离变化（下层代码变了，上层不影响）；
·保护数据
继承：提高代码重用性；多态的前提--继承
多态：
·多态的前提--继承
·多态的体现--向上转型（任何向上转型都体现了多态）
·多态的好处--提高代码扩展性
·多态的限制--向上转型发生时，子类独有的方法无法使用（唯一限制）
--工作流程：
面向对象会先从问题领域中，抽象出实体，然后使用封装、继承、多态这些特性来提高代码的重用性，扩展性等等特性, 对象和对象之间是通过消息的传递来运作的。
========================================================
27. String和StringBuffer的区别？
String长度不可变，每次修改都会产生新的空间；
StringBuffer 长度可变，每次修改都是在原空间修改
StringBuffer和StringBuilder的区别?
StringBuffer线程安全 StringBuilder不安全 两者都是长度可变字符串
=========================================================
28、Ajax请求的过程--流程（原生）
工作中使用jQuery来实现Ajax请求和处理的。
Ajax是一个异步请求数据的技术，做局部刷新，提高用户体验度和程序性能。--Asynchronized JavaScript And Xml
1.创建异步调用对象XMLHttpRequest
2.创建新的HTTP请求--并指定该请求的方法、URL及验证信息
3.设置响应http请求状态变化的函数
4.发送http请求
5.获取异步调用返回的函数
6.使用JavaScript和DOM实现局部刷新
---------------------------------
29、*****Json
1:
JavaScript Object Notation
轻量级数据转换格式，包含两种 json对象和json数组
30、hibernate （持久化对象）PO对象的三态(即生命周期)
1、临时状态（暂时态） 在对象中假设对象刚被创建但没有被持久化的话就是临时态
特点：
1、不和 Session 实例关联
2、在数据库中没有和瞬时对象关联的记录
3、如果使用的是代理主键，标识属性值默认为null
2、持久状态 持久化对象就是已经被保存进数据库的实体对象，而且这个实体对象如今还处于Hibernate的Session缓存管理之中。这时对该实体对象的不论什么改动。都会在清理缓存时同步到数据库中。
特点：
1、持久的实例在数据库中有相应的记录。
2、拥有一个持久化标识(identifier).
3、和session相关联的对象。
3、游离状态 当一个持久化对象，脱离开Hibernate的缓存管理后。它就处于游离状态，游离对象和自由对象的最大差别在于，游离对象在数据库中可能还存在一条与它相应的记录，仅仅是如今这个游离对象脱离了Hibernate的缓存管理，而自由对象不会在数据库中出现与它相应的数据记录。
特点：
1、不和Session 实例关联
2、如果使用的是代理主键，标识属性值有对应的主键值
3、数据库中有对应的数据记录
3种状态之间如何转换：
·SVN: subversion 开源版本控制器，采用分支管理系统，达到多人合作开发一个项目，公用资源的目的。
31·常用Linux命令：
1、ls -l
ls全称是list，列出指定路径下的所有文件，-l表示显示文件的完整属性
2、pwd
表示显示当前所在的目录，当我们操作很多目录之前不知道当前目录所在时就可以用这个命令来查看。
3、date clock hwclock 管理时钟命令分为硬件时钟和系统时钟，两个时间很可能不一致。
date命令是系统时钟，而其他两个则是硬件时钟。
4、COMMAND --help
可以进行命令的执行帮助，还可以用man命令，直接查看命令的手册。不过help命令更加常用。
5、passwd
用来修改密码，输入旧密码后换行，输入两次新的密码即可完成密码修改，如果反悔了按ctrl+c可以终止命令。
6、shutdown -h now
表示立即关机，就可以关闭Linux系统。
是项目构建和依赖管理的自动化管理工具。
项目构建：将源代码、配置文件变成可执行的war包或者jar包。
依赖管理：项目的正常运行必须依赖第三方jar包，即第三方的jar包的依赖管理。
·Maven的优点：
1、jar包不用手动添加到WEB-INF/lib目录下: 借助Maven，可以将jar包仅仅保存在“仓库”中，有需要使用的工程只需要“引用”这个文件
，并不需要重复拷贝到工程中。
2、Maven联网自动下载jar包:先在本地仓库中找，找不到就在网上下载。
3、项目中一个jar包所依赖的其他jar包会自动导入。
4、Maven可以将一个项目拆分成多个工程。
33 SpringBoot
Spring Boot是一个基于Spring的衍生框架，其主要的目的是帮助我们快速构建独立、生产级别的Spring的应用,其崇尚的理念是“约定优于配置”。
它是一个“微框架”，适合快速搭建项目，通过近乎零配置的方式达到快速开发的目的。当然，由于默认的设置太多，如果有特殊需求依然会涉及一系列配置文件。
设计目的 是用来简化新Spring应用的初始搭建以及开发过程