本文详细介绍了Spring MVC的配置过程，包括请求映射、异常处理、拦截器设置等内容，并探讨了Spring MVC中提交数据和返回数据的方法。此外，还深入讨论了Hibernate的使用技巧，涉及FetchType的选择、SessionFactory的操作、实体保存策略以及注解JoinColumn的应用。
spring注解不允许类命名冲突
纵然java是允许我们在不同package中可以创建相同名称的类，但是如果我们使用springmvc的话就会发现这是有悖java基础的，究其原因是在spring在将我们的类文件注解成bean的时候会使用全局扫描注解，这就会将在配置文件中定义的base-package目录下的所有类都一起捆绑到一个Collection集合中，在这里就会出现冲突conflict报错。所以如果你们有使用注解就不会引入这种错误。
参考资料：http://blog.youkuaiyun.com/chjttony/article/details/6301523
使用GSON完成对象和json之间的转换
http://code.google.com/p/google-gson/
User user = new User();
new Gson().toJson(user);
OBJECT转json最初调用的是toJson但实际上，我们看到内部是一层层的调用如下关系
public String toJson(Object src)
{
if (src == null) {
return toJson(JsonNull.INSTANCE);
}
return toJson(src, src.getClass());
}
public String toJson(Object src, Type typeOfSrc)
{
StringWriter writer = new StringWriter();
toJson(src, typeOfSrc, writer);
return writer.toString();
}
public void toJson(Object src, Type typeOfSrc, Appendable writer)
throws JsonIOException
{
try
{
JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));
toJson(src, typeOfSrc, jsonWriter);
}
catch (IOException e)
{
throw new JsonIOException(e);
}
}
最终会将数据写入jsonWriter输出，TypeToken获取对象的真正类型
public void toJson(Object src, Type typeOfSrc, JsonWriter writer)
throws JsonIOException
{
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
boolean oldLenient = writer.isLenient();
writer.setLenient(true);
boolean oldHtmlSafe = writer.isHtmlSafe();
writer.setHtmlSafe(this.htmlSafe);
boolean oldSerializeNulls = writer.getSerializeNulls();
writer.setSerializeNulls(this.serializeNulls);
try
{
adapter.write(writer, src);
}
catch (IOException e)
{
throw new JsonIOException(e);
}
finally
{
writer.setLenient(oldLenient);
writer.setHtmlSafe(oldHtmlSafe);
writer.setSerializeNulls(oldSerializeNulls);
}
}
net.sf.json.JSONException: There is a cycle in the hierarchy
http://www.2cto.com/kf/201303/198961.html这篇文章已经写的很全了！就不多说了最安全的方式就是文章中的第三种，但编码却不轻松！毕竟若果是hibernate，而且要导出大量属性，过滤的也很多。怎么都是悲剧
JSON: Property 'xxx' has no getter method in class 'class xxx'
http://blog.youkuaiyun.com/itmyhome1990/article/details/7010528引用一个大神的blog========mark
Spring MVC 配置请求的默认处理器
http://blog.youkuaiyun.com/mybackup/article/details/7245934引用文章！
<span style="font-size:14px;"> <mvc:resources mapping="/**" location="/" /> 配置静态文件</span>
Hibernate中No row with the given identifier exists
http://blog.youkuaiyun.com/eyejava/article/details/1896492问题出在数据库的数据，表之间的映射不完全！需要update tablename更新中的数据，将没有映射的内容更新
SVN删除的内容提交冲突，文件移植位置提交冲突
删除的内容提交冲突：将SVN上的包覆盖回来，再在本地删除，在提交（网传这是SVN的bug）切记：一次删除一个文件再提交。文件移植位置提交冲突：先将SVN上原来的文件删除，在提交
@RequestBody标签
<span style="font-size:14px;">public Map<String, Object> Add(@RequestBody RejStock rejStock,HttpServletRequest request){
控制层获取json字符串自动转义为注解的类对象
ajax传输一个json字符串
var json = JSON.stringify({
"stockIn" : stockIn,
"ordership" : ordership,
"orderDate" : orderDate,
"creationDate" : creationDate,
"reason" : reason,
"rejDetailList" : rejDetailList
});
$.ajax({
type: "POST",
url: "${ctx}/invt/rejin/add",
contentType : "application/json;charset=utf-8" ,
data: json,
success: function(data) {
if(data.success){
// 添加成功,刷新表单
art.dialog.tips('添加成功');
parent.location.href ="${ctx}/invt/rejin/list?parentId=${parentId}";
api.close();
}else{
art.dialog.alert('操作失败，错误信息：'+data.msg);
$submit.prop("disabled",false);
}
}
});
</span>Spring MVC配置
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<!-- 编码过滤器，解决乱码问题 -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置spring监听器 -->
<listener>
<listener-class>cn.com.dgpost.framework.listener.OspContextLoaderListener</listener-class>
<!-- default: /WEB-INF/applicationContext.xml -->
</listener>
<!-- 初始化 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/applicationContext*.xml</param-value>
</context-param>
<filter>
<filter-name>HiddenHttpMethodFilter</filter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilter</filter-name>
<servlet-name>springDispatcher</servlet-name>
</filter-mapping>
<!-- Spring会创建一个WebApplicationContext上下文，称为父上下文（父容器） ，保存在 ServletContext中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE的值。
可以使用Spring提供的工具类取出上下文对象：WebApplicationContextUtils.getWebApplicationContext(ServletContext);DispatcherServlet是一个Servlet,可以同时配置多个，
每个 DispatcherServlet有一个自己的上下文对象（WebApplicationContext），称为子上下文（子容器），子上下文可以访问父上下文中的内容，但父上下文不能访问子上下文中的内容。 它也保存在 ServletContext中，key是"org.springframework.web.servlet.FrameworkServlet.CONTEXT"+Servlet名称。当一个Request对象产生时，会把这个子上下文对象（WebApplicationContext）保存在Request对象中，key是DispatcherServlet.class.getName() + ".CONTEXT"
可以使用工具类取出上下文对象：RequestContextUtils.getWebApplicationContext(request); -->
<!-- servlet方式加载bean method 1
spring容器放在ServletContext中的key是
ServletContext sc
WebApplicationContext attr = (WebApplicationContext)sc.getAttribute("org.springframework.web.servlet.FrameworkServlet.CONTEXT.springMVC");
-->
<!--springMVC 配置 -->
<!-- 处理请求映射halderingMapping -->
<!-- 在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。 -->
<servlet>
<!-- 可以有多个servlet，通过名字的不同进行区分，对比Map存储Key的唯一性 -->
<!-- 每一个DispatcherServlet有自己的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中 -->
<servlet-name>springDispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!-- param-name指明了配置文件的文件名，不使用默认配置文件名
1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml
2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>
3、<param-value>classpath*:springMVC-mvc.xml</param-value>
4、多个值用逗号分隔 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/spring_mvc_servlet.xml</param-value>
</init-param>
<!-- 启动顺序 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 请求映射实现类会对所有以"/"结尾的URL请求进行拦截 -->
<servlet-mapping>
<servlet-name>springDispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- lazy-init 加载bean method 3 用于持有ApplicationContext,可以使用SpringContextHolder.getBean('xxxx')的静态方法得到spring bean对象 -->
<!-- istener方式加载bean method 2
ServletContext context = getServletContext();
WebApplicationContext applicationContext = WebApplicationContextUtils .getWebApplicationContext(context);
-->
<!-- Spring 刷新Introspector防止内存泄露 -->
<!-- 使用了listener监听器来加载配置 -->
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<!-- openSessionInView -->
<filter>
<filter-name>openSessionInView</filter-name>
<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>openSessionInView</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 产品条形码生成 -->
<servlet>
<servlet-name>CreateBarCode</servlet-name>
<servlet-class>cn.com.dgpost.framework.utils.barcode.OspBarcodeServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CreateBarCode</servlet-name>
<url-pattern>/CreateBarCode</url-pattern>
</servlet-mapping>
<!-- CXF web service -->
<servlet>
<servlet-name>CXFServlet</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/ws/*</url-pattern>
</servlet-mapping>
<!--Comet4J消息推送
<listener>
<description>Comet4J容器侦听</description>
<listener-class>org.comet4j.core.CometAppListener</listener-class>
</listener>
<servlet>
<servlet-name>CometServlet</servlet-name>
<servlet-class>org.comet4j.core.CometServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CometServlet</servlet-name>
<url-pattern>/conn</url-pattern>
</servlet-mapping>
<listener>
<listener-class>cn.com.dgpost.framework.comet4j.Comet4jShow</listener-class>
</listener>
-->
<!-- session 超时时间 -1表示永不超时-->
<session-config>
<session-timeout>300</session-timeout>
</session-config>
<!-- 欢迎页面 -->
<welcome-file-list>
<welcome-file>/index.jsp</welcome-file>
</welcome-file-list>
<!-- 出错页面定义 -->
<error-page>
<error-code>404</error-code>
<location>/page404</location>
</error-page>
<!--
<error-page>
<error-code>403</error-code>
<location>/common/403.jsp</location>
</error-page>
<error-page>
<error-code>500</error-code>
<location>/common/500.jsp</location>
</error-page> -->
</web-app>
spring-servlet.xml
<?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:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:p="http://www.springframework.org/schema/p"
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/jee
http://www.springframework.org/schema/jee/spring-jee-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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd"
default-autowire="byName" default-lazy-init="true">
<!-- 开启注解扫描 -->
<!-- 自动扫描的包名，不区分大小写，因为创建包的时候就不区分大小写 -->
<context:component-scan base-package="cn.com.dgpost.osp.*controller" />
<!-- <context:component-scan/> 扫描指定的包中的类上的注解，常用的注解有：
@Controller 声明Action组件
@Service 声明Service组件 @Service("myMovieLister")
@Repository 声明Dao组件
@Component 泛指组件, 当不好归类时.
@RequestMapping("/menu") 请求映射
@Resource 用于注入，( j2ee提供的 ) 默认按名称装配，@Resource(name="beanName")
@Autowired 用于注入，(srping提供的) 默认按类型装配
@Transactional( rollbackFor={Exception.class}) 事务管理
@ResponseBody
@Scope("prototype") 设定bean的作用域 -->
<!-- 默认的注解映射的支持 -->
<!-- <mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式
<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的。
并提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson） -->
<!--自动注入 DefaultAnnotationHandlerMapping,AnnotationMethodHandlerAdapter
<mvc:annotation-driven />
-->
<!-- 拦截器 method 1-->
<!-- <mvc:interceptors/> 是一种简写形式。
我们可以配置多个HandlerMapping。会为每一个HandlerMapping，注入一个拦截器。其实我们也可以手动配置为每个HandlerMapping注入一个拦截器。 -->
<!-- <mvc:interceptors/>会为每一个HandlerMapping，注入一个拦截器。总有一个HandlerMapping是可以找到处理器的，最多也只找到一个处理器，所以这个拦截器总会被执行的。起到了总拦截器的作用。
如果是REST风格的URL，静态资源也会被拦截。 -->
<!-- <mvc:interceptors>
<bean class="cn.com.dgpost.framework.interceptor.LoginInterceptor" />
</mvc:interceptors> -->
<!-- 通过配置文件拦截匹配的URL method 2
<mvc:interceptors >
<mvc:interceptor>
<mvc:mapping path="/user/*" />
<bean class="com.mvc.MyInteceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
-->
<!-- 视图解释类 -->
<!-- spring注解 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
<!-- REST风格的URL，静态资源就不会被拦截。精准的注入了拦截器。 method 3 -->
<property name="interceptors">
<list>
<!-- 登录拦截器 -->
<bean class="cn.com.dgpost.framework.interceptor.LoginInterceptor"/>
</list>
</property>
<!-- 三种URL"/simple"，"/simple.*"，"/simple/"映射 禁用两种映射("/simple.*"，"/simple/")， -->
<property name="useSuffixPatternMatch" value="false"></property>
</bean>
<!-- 异常处理-->
<!-- SimpleMappingExceptionResolver类，和他的父类AbstractHandlerExceptionResolver类。
可以实现HandlerExceptionResolver接口，写一个自己的异常处理程序
同时我们也可以为所有的异常指定一个默认的异常提示页面（通过defaultErrorView属性的配置），如果所抛出的异常在exceptionMappings中没有对应的映射，则Spring将用此默认配置显示异常信息。
注意这里配置的异常显示界面均仅包括主文件名，至于文件路径和后缀已经在viewResolver中指定。如/error/error表示/error/error.jsp-->
<!-- <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="defaultErrorView">
<value>/error/error</value>
</property>
<property name="defaultStatusCode">
<value>500</value>
</property>
<property name="warnLogCategory">
<value>org.springframework.web.servlet.handler.SimpleMappingExceptionResolver</value>
</property>
</bean> -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<!-- 表单日期转换 -->
<property name="webBindingInitializer">
<bean class="cn.com.dgpost.framework.webBind.OspDataBinding" />
</property>
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter"/>
<!--json 转换 -->
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<!-- 日期处理 -->
<property name="objectMapper">
<bean class="com.fasterxml.jackson.databind.ObjectMapper">
<property name="dateFormat">
<bean class="java.text.SimpleDateFormat">
<constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss"></constructor-arg>
</bean>
</property>
</bean>
</property>
</bean>
</list>
</property>
</bean>
<context:annotation-config />
<!-- 打印模板解析器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
<property name="order" value="0"></property>
<property name="basename" value="views"/>
</bean>
<!-- ContentNegotiatingViewResolver 分配视图解析器：客户端的不同的请求决定不同的view -->
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="order" value="1"></property>
<property name="defaultContentType" value="application/json" />
<property name="mediaTypes">
<map>
<entry key="html" value="text/html" />
<entry key="json" value="application/json" />
</map>
</property>
<property name="viewResolvers">
<list>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/WEB-INF/view/" />
<property name="suffix" value=".jsp" />
</bean>
</list>
</property>
</bean>
<!-- 上传拦截，如最大上传值及最小上传值 p:defaultEncoding="UTF-8"-->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver" >
<property name="defaultEncoding">
<value>UTF-8</value>
</property>
<property name="maxUploadSize" value="20000000" />
<property name="maxInMemorySize" value="4096" />
</bean>
<!-- 静态资源文件配置 method 3
要写在web.xml让tomcat的defaultServlet先进行拦截，写在springDispatcherServlet之前 -->
<!-- <servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.jpg</url-pattern>
</servlet-mapping> -->
<!-- 对静态资源文件的访问 method 2 -->
<!-- <mvc:default-servlet-handler/> 使用默认的Servlet来响应静态文件。 -->
<mvc:default-servlet-handler/>
<!-- 静态资源文件配置 method 1-->
<!-- 匹配URL /images/** 的URL被当做静态资源，由Spring读出到内存中再响应http -->
<!-- 如何你的DispatcherServlet拦截"*.do"这样的有后缀的URL，就不存在访问不到静态资源的问题。
如果你的DispatcherServlet拦截"/"，为了实现REST风格，拦截了所有的请求，那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。 -->
<mvc:resources mapping="/resources/**" location="/resources/" cache-period="31536000" />
<mvc:resources mapping="/attached/**" location="/attached/" cache-period="31536000" />
<mvc:resources mapping="/UPLOAD_PIC_/**" location="/UPLOAD_PIC_/" cache-period="31536000" />
<mvc:resources mapping="/UPLOAD_ATTACHMENT_/**" location="/UPLOAD_ATTACHMENT_/" cache-period="31536000" />
<mvc:resources mapping="/app_osp/upload/**" location="/app_osp/upload/" cache-period="31536000" />
</beans>
Srping mvc提交数据和返回数据方法
/**
* 提交数据
* 1:使用@RequestParam 注解获取GET请求或POST请求提交的参数；
* public String testParam(PrintWriter out, @RequestParam("username") String username)
*
* 2:从@RequestMapping注解标记的访问路径中获取参数：
* @RequestMapping("/index/{username}")
* public String index(@PathVariable("username") String username) {
*
*
* 3:可以传入HttpServletRequest、HttpServletResponse、HttpSession
* @RequestMapping(value = "login", method = RequestMethod.POST)
* public String testParam(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
* String username = request.getParameter("username");
*
*
* 4:获取表单中提交的值，并封装到POJO中，传入Controller的方法里：
* POJO如下（User.java）
* public class User{
* private long id;
*
* 通过表单提交，直接可以把表单值封装到User对象中：
* @RequestMapping(value = "login", method = RequestMethod.POST)
* public String testParam(PrintWriter out, User user) {
*
*/
/**
* Controller中方法的返回值：
* void：多数用于使用PrintWriter输出响应数据；
* String 类型：返回该String对应的View Name；
* 任意类型对象：
* 返回ModelAndView：
* 自定义视图（JstlView，ExcelView）：
* 拦截器（Inteceptors）：
* public class MyInteceptor implements HandlerInterceptor {
* public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o)
* throws Exception {
* return false;
* }
* public void postHandle(HttpServletRequest request, HttpServletResponse response, Object o, ModelAndView mav)
* throws Exception {
* }
* public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object o, Exception excptn)
* throws Exception {
* }
*
* 拦截器需要实现HandleInterceptor接口，并实现其三个方法：
* preHandle：拦截器的前端，执行控制器之前所要处理的方法，通常用于权限控制、日志，其中，Object o表示下一个拦截器；
* postHandle：控制器的方法已经执行完毕，转换成视图之前的处理；
* afterCompletion：视图已处理完后执行的方法，通常用于释放资源；
* 在MVC的配置文件中，配置拦截器与需要拦截的URL：
* <mvc:interceptors>
* <mvc:interceptor>
* <mvc:mapping path="/index.htm" />
* <bean class="com.minx.crm.web.interceptor.MyInterceptor" />
* </mvc:interceptor>
* </mvc:interceptors>
*
*
* controller返回类型
* 1：ModelAndView
* ModelAndView modelAndView = new ModelAndView("/user/index");
* modelAndView.addObject("xxx", "xxx");
* return modelAndView;
*
* ModelAndView modelAndView = new ModelAndView();
* modelAndView.addObject("xxx", "xxx");
* modelAndView.setViewName("/user/index");
*
* 2：Model一个模型对象
*
* 3：Map
* Map<String, String> map = new HashMap<String, String>();
* map.put("1", "1");
* //map.put相当于request.setAttribute方法
* return map;
*
*
*/以上内容来自网络！
下边开始查看SPRING文档（版本3.2.3release）
Spring的FetchType
1、FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载。2、FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。
3、比方User类有两个属性，name跟address，就像百度知道，登录后用户名是需要显示出来的，此属性用到的几率极大，要马上到数据库查，用急加载；而用户地址大多数情况下不需要显示出来，只有在查看用户资料是才需要显示，需要用了才查数据库，用懒加载就好了。所以，并不是一登录就把用户的所有资料都加载到对象中，于是有了这两种加载模式。
Attempted to serialize java.lang.Class: org.hibernate.proxy.HibernateProxy. Forgot to register a typ
用 hibernate 查询的那个实体类中肯定有一对多的关系，hibernate 默认是使用的延迟加载，不会查出多的那一方，而是返回一个代理，只有实际使用的时候才会去查。所以你查出来的对象里面有代理，Gson 识别不了
hibernate id to load is required for loading
需要的参数没有
hibernate的sessionFactory
http://blog.youkuaiyun.com/hvhvhwhw_xd/article/details/41294597
evict(obj)清除指定对象
clear()清除session中所有对象
数据库查询执行操作序列：
gethibernateFactroy.getcurrentsession
开启事务session.beginTransaction
增删改查操作
提交事务session.getTransaction.commit（将所有session flush到数据库中）
关于hibernate保存对象save,persist,saveorupdate
persist 保证在transaction外部调用的时候不会触发insert
当遇到长会话长事务时，save很可能在事务已经结束后才发生。这时save仍然可以执行，而persist就不能执行了，所以persist相对安全，而且是hibernate推荐的标准写法
Hibernate注解JoinColumn
@ManyToMany ---> ManyToMany指定多对多的关联关系
@JoinTable(name="t_teacher_course", joinColumns={ @JoinColumn(name="cid")}, inverseJoinColumns={ @JoinColumn(name = "tid") }) ---> 因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过JoinTable
这个注解来声明，name就是指定了中间表的名字JoinColumns是一个 @JoinColumn类型的数组，表示的是我这方在对方中的外键名称，我方是Course，所以在对方外键的名称就是 rid，inverseJoinColumns也是一个 @JoinColumn类型的数组，表示的是对方在我这放中的外键名称，对方是Teacher，所以在我方外键的名称就是 tid
Hibernate使用创建对象关系映射实体
一定要有ID主键识别，类型要为整型
扫一扫
264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
