ba

grill:在烤架（用平行金属条制成的烹调用具）上烤. bake：用热量干烤,尤指在烤炉里. roast：用热量干烤,在烤炉里,或用煤炭. fry:干炸 vt.蒸,散发；用蒸汽处理 vi.蒸,冒水汽 stew: vt.炖,炖汤；焖；忧虑；受闷热 steam: vt.蒸,散发；用蒸汽处理 vi.蒸,冒水汽

alone(bee gees)

roast的意思是：tocookfoodinanovenoroverafire；bake的意思是：tocookinsideacooker,withoutusingaddedliquidorfat所以如果是roastchicken的话，就是在烤箱里或者用火烧烤都可以的，烤的时候加调料和油什么的都行。如果是bakedchicken的话，就只可能是在炉子里考的，并且不加调料和油的。一般肉类beef/chicken什么的用roast比较多而cake/bread用bake比较多有些东西，如potatoes用什么都ok了。

baoshiting是香奈儿牌子的包。 香奈儿公司是欧洲知名的奢侈品生产品牌。这款香奈儿包是香奈儿公司最新推出来的产品，使用了澳大利亚进口的鳄鱼皮制作，其质量非常优越。这款包是一款小型的女士挎包，外形十分精美，特别适合年轻女士佩戴。

是不是美国的一首英文歌开头是一个电音拉拉拉拉拉乌拉乌拉乌拉2男2女唱的 有一个演唱会视频 在中间高潮的时候那个男的唱碗的那个币去是不是 之前百度一下找到了这首歌名字 现在找不到了 那个演唱会有歌曲名字6个字母 f开头的

我们来就是赢得胜利的！

1

maroonbanner是七种颜色。根据查询潘通maroonbanner公开信息得知，有红色、黑色、黄色、白色、蓝色、紫色、绿色。MaroonBanner属于潘通PANTONETCX棉布板色卡

不同行业，不同产品的pcba都不相同，4G/5G电子产品，航空电子、汽车电子，医疗电子的pcba板有大有小，但是对可靠性、品质要求特别高，因此电子元件的贴装技术要求也非常高，贴装精度要求高。Pcba加工工艺流程1. pcb锡膏印刷Pcb电路板经过上板机流入到锡膏印刷机，印刷机将锡膏透过钢网将锡膏印刷到电路板指定的焊盘位置，延伸阅读：（SMT贴片加工中锡膏有哪几种类，存储及使用环境的基本认识）为贴片机贴装元件做准备；2. spi检测锡膏印刷机印刷完pcb后，流入到spi，spi是锡膏自动光学检查机，通过光学将锡膏印刷的品质好坏呈现出来，这是smt非常重要的检测工序；3. 贴片机锡膏检查机检测完pcb电路板锡膏印刷品质后，通过贴片机将各类电子元件贴装到指定的焊盘上，电子元件与pcb电路板的粘粘就是锡膏发挥了作用，这仅仅只是起到粘粘作用，后面还有关键的一道工序；4. 回流焊经过贴片机将电子元件与pcb贴装好，需要经过回流焊焊接，将锡膏融化，将电子元件牢牢的固定在pcb焊盘上，发挥电子元件的作用；5. AOI由于目前的很多电子产品越来越小型化和功能多样化，电子元器件体积也越来越小，因此经过回流焊接的品质如何，通过人眼是目测检查不出来，因此AOI就应运而生，AOI的主要作用就是检查pcb焊接的品质，比如：是否连桥，立碑，锡珠、葡萄球，多锡等现象；现在越来越重视产品的稳定性和性能品质，因此AOI检查非常有必要。6. 自动下板机、分板机通过回流焊焊接后，则需要下板机将板子收集，然后再通过分板机将拼板切割成一块块的pcba。7. 插件机有些pcba因为需要用到异形件和贴片机无法贴装的电子元件，因此需要自动插件机或人工插件，将电子元件插入pcb通孔中，这道工序就是业内常说的DIP插件；8. 波峰焊经过自动插件或人工插件后，异形件或大料电子元件需要通过波峰焊将元件与pcb固定，波峰焊的作用与回流焊的作用类似，但是原理不一样，下次再跟大家讲解二者间的区别。9. 点胶、覆膜、老化测试到了此步骤，一块完整的pcba板基本就差不多制造完成，点胶的作用就是将有些电子元件更加好的固定，覆膜的作用就是给pcba板涂上一种膜，增加pcba的品质，防腐蚀、防水等，老化测试就是全部工序制造完成，通过数小时的连续导电进行连续性测试，看pcba板的稳定性。以上的工序只是pcba加工最基础的工艺种类，很多电子产品还有额外的功能测试和其他多方面的检测，因此pcba加工是比较严谨的制作。

一样。maroon为褐红色，bay为红棕色，二者颜色一样，只是气体常用红棕色来表示，固体常用红褐色来表示。颜色是通过眼、脑和我们的生活经验所产生的一种对光的视觉效应。

[综合评价] 高中时期平均每场贡献36.6分、10.1个篮板、6.2次助攻、3.3次抢断和2.8次封盖的篮球天才，Memphis State校队的灵魂人物，Michael Jordan与Magic Johnson的混合体，篮球场上的Elvis Presley，拥有全联盟最美迷人微笑的男人。心比天高，命比纸薄，左膝的数次手术终于让他无奈的沦为平庸。目前，心态平和的他已经逐渐接受了角色球员的身份，组织、防守和策应成了他的专职工作，但是在他的心中却从未放弃过对“复活”渴求。 [进攻] 早期的Penny能够依靠骇人的身体素质轻松切入篮下，上演双手重扣。同时，扎实的低位单打技术也可令同时期的任何控位叫苦不迭。相比精准的中距离跳投，Penny在3分线外的威胁一般，但是遇到关键球，Penny永远是球队的第一选择。总之，Penny可以在任何位置以任何方式得分。此外，Penny匪夷所思的传球使他的进攻更具威胁：不包夹他，你会死的很惨；若包夹他，你会死的更惨！目前，34岁的Penny已经大大减少了突破的频率，投篮点通常是在3分线往里一步的位置，尽管Penny的3分球命中率已经达到了他职业生涯最好的水准，但是他目前的投篮远没有他的传球来得更有威胁。 [防守] 早期的Penny有着惊人的速度，这使得他在对位对方控球后卫时不会脚下吃亏。同时，Penny高大的身形也足以使他在防守对方的攻击后卫或小前锋时游刃有余。相对于早期注重抢断和封盖的防守方式，受伤之后的Penny更加注重贴身防守，尽管数据很难体现，但是今时今日，Penny依旧是球队防守对方尖刀人物的首要人选。 [位置] Penny在魔术时期充当控球后卫，在太阳时代充当攻击后卫，在尼克斯时代充当小前锋，但是位置对于Penny来说毫无意义，因为Penny没有必要苦恼与传与投的取舍，就像Magic一样，Penny是在依靠本能打球，依靠天赋打球。目前，随着比赛经验的增加，Penny阅读比赛的能力达到了更高的层次，对于节奏的控制也更加老道，身体虽然退化了，但是他仍旧会是一位称职的球场指挥官。 [其他] 生于单亲家庭，童年生活困苦，自小由祖母带大，并从老人那里得到Penny这个绰号。热衷慈善事业，嗜高尔夫如命。天性乐观，却很固执，不善言辞，略有洁癖。大学时穿25号球衣，加盟魔术后，由于与Nick Anderson号码撞车，改穿1号球衣，直到今日。联盟中最要好的朋友是Bo Outlaw，与Kobe Bryant素有不合。至今未婚，但是有一个女儿。 [简要经历] 1990年以3039分创造Treadwell高中校队得分记录；1992年获得分区最佳新人和年度最佳球员，入选美国篮球发展队；1993年以729分创造Memphis State历史单季得分最高记录，以首轮第3顺位被勇士选中，随即与Chris Webber对换，加盟魔术；1994年25号球衣在Memphis State退役，获得新秀赛MVP，拍摄电影《Blue Chips》；1995年入选全明星，入选联盟最佳阵容第一队；1996年入选全明星，入选联盟最佳阵容第一队，随“梦三队”获得奥运会金牌；1997年入选全明星，入选联盟最佳阵容第三队；1998年入选全明星；1999年转会太阳，左臂增加新文身，上书：Part II Heaven Cent；2003年获得Memphis State学士学位，右臂增加新文身，上书：The storm is over;；2004年转会尼克斯。2008年加盟热队，只打了几场球。

当然免费的。

Band.in.a.Box2005是中文版的

mybatis-plus中设置了默认值（如statu默认值为0）,但我在save时对象的statu属性有值为1,它的值是1还是0呢？（目前测了一次是0）想知道默认值设置的原理解析，请大神指教

why would i ever . .我原来最爱听这个了

这首歌是《漂亮男孩》，演唱者是艾薇儿。扩展资料歌词：I lie awake at night 晚上我躺在床上没有一点睡意 See things in black and white 世界对我来说只有黑与白 I"ve only got you inside my mind 你的形象无时无刻不在我脑中闪动 You know you have made me blind 我的眼里只有你 I lie awake and pray 我清醒地躺在床上祈祷 that you will look my way 祈祷你会看见我 I have all this longing in my heart 我的心中充满渴望 I knew it right from the start 一开始我就知道 Oh my pretty pretty boy I love you 我的漂亮男孩 我爱你 Like I never ever loved no one before you 在你之前我从未这样爱过一个人 Pretty pretty boy of mine 我的漂亮男孩 Just tell me you love me too 告诉我你也爱我 Oh my pretty pretty boy I need you 我的漂亮男孩我需要你 Oh my pretty pretty boy I do 我的漂亮男孩，是真的 Let me inside make me stay right beside you 让我进来让我留在你身旁 I used to write your name 我曾写下你的名字 And put it in a frame 并把它框起来 And sometimes I think I hear you call 有时我以为我听见的呼唤 Right from my bedroom wall 有时我觉得我在我房间里听到了你的呼唤 You stay a little while 你待了一会儿 And touch me with your smile 用你的微笑打动我的心 And what can I say to make your mine 我该说什么才能赢得你的心 To reach out for you in time 才能及时掳获你 Oh my pretty pretty boy I love you 我的漂亮男孩 我爱你 Like I never ever loved no one before you 在你之前我从未这样爱过一个人 Pretty pretty boy of mine 我的漂亮男孩 Just tell me you love me too 告诉我你也爱我 Oh my pretty pretty boy I need you 我的漂亮男孩 我需要你 Oh my pretty pretty boy I do 我的漂亮男孩 是真的 Let me inside 让我进来 make me stay right beside you 让我留在你身旁 Oh pretty pretty boy 我的漂亮男孩 say you love me too 说你也爱我 Oh my pretty pretty boy I love you 我的漂亮男孩 我爱你 Like I never ever loved no one before you 在你之前我从未这样爱过一个人 Pretty pretty boy of mine 我的漂亮男孩 Just tell me you love me too 告诉我你也爱我 Oh my pretty pretty boy I need you 我的漂亮男孩 我需要你 Oh my pretty pretty boy I do 我的漂亮男孩 是真的 Let me inside 让我进来 make me stay right beside you 让我留在你身边

需要，，ibatis只是写sql语句的。一般传值接收值，还是用类控制的。

强劲地吹刮，仿佛只为了巨岩，只为在它身上撕开空隙轻轻一片……　　啊，还有山顶上，目光中，一株繁茂的无花果在全心将你体验。

1、用script标签包围，然后像xml语法一样书写@Select({"<script>", "SELECT * FROM tbl_order", "WHERE 1=1", "<when test="title!=null">", "AND mydate = #{mydate}", "</when>", "</script>"})2、用Provider去实现SQL拼接，例如：public class OrderProvider { private final String TBL_ORDER = "tbl_order"; public String queryOrderByParam(OrderPara param) { SQL sql = new SQL().SELECT("*").FROM(TBL_ORDER); String room = param.getRoom(); if (StringUtils.hasText(room)) { sql.WHERE("room LIKE #{room}"); } Date myDate = param.getMyDate(); if (myDate != null) { sql.WHERE("mydate LIKE #{mydate}"); } return sql.toString(); }}public interface OrderDAO { @SelectProvider(type = OrderProvider.class, method = "queryOrderByParam") List<Order> queryOrderByParam(OrderParam param);}注意：方式1有个隐患就是当传入参数为空的时候，可能会造成全表查询。复杂SQL用方式2会比较灵活（当然，并不建议写复杂SQL），而且可以抽象成通用的基类，使每个DAO都可以通过这个基类实现基本的通用查询，原理类似Spring JDBC Template。

竟然Mybatis是对四大接口进行拦截的，那我们药先要知道Mybatis的四大接口对象 Executor, StatementHandler, ResultSetHandler, ParameterHandler。上图Mybatis框架的整个执行过程。Mybatis插件能够对则四大对象进行拦截，可以包含到了Mybatis一次会议的所有操作。可见Mybatis的的插件很强大。Executor是 Mybatis的内部执行器，它负责调用StatementHandler操作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的操作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。StatementHandler是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的操作(禁用等等)。ParameterHandler是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。ResultSetHandler是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。插件InterceptorMybatis的插件实现要实现Interceptor接口，我们看下这个接口定义的方法。public interface Interceptor {Object intercept(Invocation invocation) throws Throwable;Object plugin(Object target);void setProperties(Properties properties);}这个接口只声明了三个方法。setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Plugin.wrap(target, this);intercept方法就是要进行拦截的时候要执行的方法理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。Mybatis四大接口对象创建方法Mybatis的插件是采用对四大接口的对象生成动态代理对象的方法来实现的。那么现在我们看下Mybatis是怎么创建这四大接口对象的。public Executor newExecutor(Transaction transaction, ExecutorType executorType) {//确保ExecutorType不为空(defaultExecutorType有可能为空)executorType = executorType == null ? defaultExecutorType : executorType;executorType = executorType == null ? ExecutorType.SIMPLE : executorType;Executor executor; if (ExecutorType.BATCH == executorType) {executor = new BatchExecutor(this, transaction);} else if (ExecutorType.REUSE == executorType) {executor = new ReuseExecutor(this, transaction);} else {executor = new SimpleExecutor(this, transaction);} if (cacheEnabled) {executor = new CachingExecutor(executor);}executor = (Executor) interceptorChain.pluginAll(executor);return executor;}public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);return statementHandler;}public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);return parameterHandler;}public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);return resultSetHandler;}查看源码可以发现， Mybatis框架在创建好这四大接口对象的实例后，都会调用InterceptorChain.pluginAll()方法。InterceptorChain对象是插件执行链对象，看源码就知道里面维护了Mybatis配置的所有插件(Interceptor)对象。// target --> Executor/ParameterHandler/ResultSetHander/StatementHandlerpublic Object pluginAll(Object target) {for (Interceptor interceptor : interceptors) {target = interceptor.plugin(target);}return target;}其实就是安顺序执行我们插件的plugin方法,一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口对象的方法时候，实际上是调用代理对象的响应方法，代理对象又会调用十大接口对象的实例。Plugin对象我们知道，官方推荐插件实现plugin方法为：Plugin.wrap(target, this);public static Object wrap(Object target, Interceptor interceptor) {// 获取插件的Intercepts注解Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);Class<?> type = target.getClass();Class<?>[] interfaces = getAllInterfaces(type, signatureMap);if (interfaces.length > 0) {return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));}return target;}这个方法其实是Mybatis简化我们插件实现的工具方法。其实就是根据当前拦截的对象创建了一个动态代理对象。代理对象的InvocationHandler处理器为新建的Plugin对象。插件配置注解@InterceptsMybatis的插件都要有Intercepts注解来指定要拦截哪个对象的哪个方法。我们知道，Plugin.warp方法会返回四大接口对象的代理对象(通过new Plugin()创建的IvocationHandler处理器)，会拦截所有的执行方法。在代理对象执行对应方法的时候，会调用InvocationHandler处理器的invoke方法。Mybatis中利用了注解的方式配置指定拦截哪些方法。具体如下：public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {try {Set<Method> methods = signatureMap.get(method.getDeclaringClass());if (methods != null && methods.contains(method)) {return interceptor.intercept(new Invocation(target, method, args));}return method.invoke(target, args);} catch (Exception e) {throw ExceptionUtil.unwrapThrowable(e);}}可以看到，只有通过Intercepts注解指定的方法才会执行我们自定义插件的intercept方法。未通过Intercepts注解指定的将不会执行我们的intercept方法。官方插件开发方式@Intercepts({@Signature(type = Executor.class, method = "query",args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})public class TestInterceptor implements Interceptor {public Object intercept(Invocation invocation) throws Throwable {Object target = invocation.getTarget(); //被代理对象Method method = invocation.getMethod(); //代理方法Object[] args = invocation.getArgs(); //方法参数// do something ...... 方法拦截前执行代码块Object result = invocation.proceed();// do something .......方法拦截后执行代码块return result;}public Object plugin(Object target) {return Plugin.wrap(target, this);}}以上就是Mybatis官方推荐的插件实现的方法，通过Plugin对象创建被代理对象的动态代理对象。可以发现，Mybatis的插件开发还是很简单的。自定义开发方式Mybatis的插件开发通过内部提供的Plugin对象可以很简单的开发。只有理解了插件实现原理，对应不采用Plugin对象我们一样可以自己实现插件的开发。下面是我个人理解之后的自己实现的一种方式。public class TestInterceptor implements Interceptor {public Object intercept(Invocation invocation) throws Throwable {Object target = invocation.getTarget(); //被代理对象Method method = invocation.getMethod(); //代理方法Object[] args = invocation.getArgs(); //方法参数// do something ...... 方法拦截前执行代码块Object result = invocation.proceed();// do something .......方法拦截后执行代码块return result;}public Object plugin(final Object target) {return Proxy.newProxyInstance(Interceptor.class.getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return intercept(new Invocation(target, method, args));}});}public void setProperties(Properties properties) {}}当然，Mybatis插件的那这个时候Intercepts的注解起不到作用了。作者：曹金桂链接：http://www.jianshu.com/p/7c7b8c2c985d来源：简书著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

基于楼主应该引用了jar和插件配置。java中：1、在你执行mybatis查询之前加入如下代码PageHelper.startPage(pageInt, pagesizeInt, true);2、然后执行自己代码List<SysUser> listSysUser = sysUserService.selectByExample(sysUserExample);3、包装一下：PageInfo<SysUser> pageInfo =new PageInfo<SysUser>(listSysUser);syso.("物理总页数："pageInfo .total);pageInfo中包含了分页的所有信息，其中total就是总页数。原理：pagehelper封装了返回结果 。上面的查询列表功能只是简单的select from没有limit。但返回结果listSysUser已经分页， 实际上存储的是Page<E>（是Arraylist子类。）

把“,”改成“+”才可以用。

susan对他好。《越狱》电影中：T-bag的内心实际上是很渴望被人关怀和爱的，在遇到susan了之后就喜欢她了，因为susan温柔对他还很好。《越狱》电影讲述了：一个关于救赎的故事。电视一开始，迈克尔为了营救被别人陷害的哥哥林肯而入狱，于是他故意入狱，并制定了越狱计划逃跑，却在逃跑的过程中被抓，再次入狱。最后，想办法收集证据证明自己的清白。

你可以把springmvc当成struts2，大概就明白了。以下内容来自网络，请认真看一遍。Spring是一个轻型容器(light-weight container)，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model)。在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其他流行的Web框架进行集成。1)开源框架2)IoC（控制反转）,将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合3)AOP 将安全，事务等于程序逻辑相对独立的功能抽取出来，利用spring的配置文件将这些功能插进去，实现了按照方面编程，提高了复用性前言最近在看Spring MVC的源码,就把自己对MVC模式和对各种框架的实现的认识写出来给大家看看,算是一个总结.所以,恳请大家用怀疑的眼光来看待这篇文章,假如有认识不对的地方,麻烦指出.MVC与WEB应用MVC是什么就不用我多说了.对于现有较成熟的Model-View-Control(MVC)框架而言,其注意的主要问题无外乎下面这些:Model:模型应该包含由视图显示的数据.在J2EE Web应用中,数据通常应该由普通的javabean组成.一旦一个控制器选择了视图,模型就要包含视图相应的数据.模型本身不应该进一步的访问数据,也不应该和业务对象相联系.模型要解决的问题包括:l 封装要显示的数据l 我不认为模型要依赖于特定的框架l 不一定非得是javabeanView:视图负责显示出模型包含的信息,视图不必了解控制器或是底层业务对象的具体实现视图要解决的问题包括:l 在显示给定数据模型的情况下显示内容l 不应该包含有业务逻辑l 可能需要执行显示逻辑,比如颜色交替的显示某个数组的各行l 视图最好不处理验证的错误,数据的验证应该在由其他组件完成l 视图不应该处理参数,参数应该交由控制器集中处理Control:控制器就好像MVC里的中枢神经,它也许会需要一些助手来帮助它比如解析视图,解析参数等.控制器可以访问到业务对象或者是它的代理是很重要的,比如Struts里的Action.控制器要解决的问题包括:l 检查和抽取请求参数l 调用业务对象,传递从请求中获取的参数l 创建模型,视图讲显示对应的模型l 选择一个合适的视图发送给客户端l 控制器有时不会只有一个现有的框架现在已经有很多的MVC的框架实现.比较流行的应该就是Struts和Webwork了Struts这是最流行的web框架,几乎成为了实际上的工业标准.除了上面讨论的MVC模式应该有的优点以外.它还有如下一些缺点:l 每个Action只生成一次,然后就被缓存起来,再次请求这个Action的时候就不会生成新的对象,而是重复使用第一次生成的对象,这就意味着每个Action必须是线程安全的l 采用ActionForm封装了表单数据,但是却只能对应String类型的数据, 虽然它可以使用工具Commons Beanutils进行类型转化,但是仅仅是提供了对象级别的支持l 严重的依赖于Servlet API, 测试比较困难(不过下一版Struts里的Action.execute的方法签名讲会换成execute(ActionContext actionContext),依赖也许不会那么严重)l 框架本身的验证规则比较简单,一般都是依赖于Commons Validation进行验证l 想在Action前后做些处理很困难.有时甚至不得不自己去写专门的控制器l 由于Struts都是具体的类继承,这样很容易打破封装?l 提供各式各样的自定义的标签,但是数据绑定太原始了,这样就使页面代码依赖于Struts这个特定的框架,而它却不是规范,我觉得这是很致命的l 它太面向JSP了,尽管使用其他视图技术是有可能的,但是使用的时候却不是很方便Webwork这个框架虽然我没使用过,但是却一直在关注它的发展 Webwork的设计思想采用了比Struts更为聪明的一种方式,就技术角度上说比Struts要高出不少.它以Command模式为基础.分为Xwork和Webwork,而且框架并不依赖于Servlet API. Xwork提供了很多核心功能:拦截器（Interceptor）,运行时表单验证,类型转换,IoC容器等. WebWork建立在Xwork之上,用于处理基于HTTP的响应和请求.用Map和ActionContext封装了Session,Application等这些Servlet对象.从而解除了和Servlet API的耦合. 但是它仍然不是完美的:l 为每一个请求都创建一个Action可能有些浪费.(但是Servlet引擎也是为每个请求创建多个对象,但是也没看出来对性能有多大的影响?)l 当项目越来越大的时候,配置文件可能会很零乱.好像它不支持多个配置文件l 异常处理是Command模式里值得注意的问题:我们不知道某一特定命令可能会抛出什么特定的异常,所以execute()被迫抛出异常,而不论异常是运行时异常,还是已检查异常 Spring MVC Framework的目标上面说了一些MVC的原理,以及现在主流框架的一些问题,现在来看Spring是如何处理的. Spring MVC框架根据不同的角色定义了很多接口,但是它最大的问题也是依赖于Servlet APISpring MVC Framework有这样一些特点:l 它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件.并且和Spring提供的其他基础结构紧密集成.l 不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)l 可以任意使用各种视图技术,而不仅仅局限于JSPl 支持各种请求资源的映射策略l 它应是易于扩展的我认为评价一个框架,应该有几个原则l 它应该是易于使用的,易于测试的Spring 易于使用吗?我不这么觉得,尤其是它的配置文件.在最恐怖的情况下,各种业务逻辑,基础设施也许会拥挤在一个配置文件里.而如事务处理这些基础设施应该是由容器管理而不是开发人员,就算把这些分开到几个配置文件里,逻辑上虽然清晰了,但是基础设置却还是暴露在外边Spring易于测试吗?对Spring进行单元测试很容易,测试起来很方便l 应该在多个层次上提供接口Spring提供了很多接口,而几乎每个接口都有默认的抽象实现,每个抽象实现都有一些具体实现,所以在可扩展性这点上Spring无疑是很优秀的l 框架内部和框架外部应该被区别对待框架内部可以很复杂,但是使用起来一定要简单,Spring的内部比较麻烦,但是它很好的隐藏了这种复杂性,使用起来很舒服,比如设置一个bean的属性.仅仅是setPropertyValue(String propertyName, Object value)就完成,至于怎么去设置,Spring完全隐藏了这种复杂性l 完善的文档和测试集这个就不用说了,老外的东西,都很完善 Spring Web框架基本流程知道了Spring MVC框架,现在来看看它的流程Spring MVC Framework大至流程如下:当web程序启动的时候,ContextLoaderServlet会把对应的配置文件信息读取出来,通过注射去初始化控制器DispatchServlet. 而当接受到一个HTTP请求的时候, DispatchServlet会让HandlerMapping去处理这个请求.HandlerMapping根据请求URL(不一定非要是URL,完全可以自定义,非常灵活)来选择一个Controller. 然后DispatchServlet会在调用选定的Controller的handlerRequest方法,并且在这个方法前后调用这个Controller的interceptor(假如有配置的话),然后返回一个视图和模型的集合ModelAndView.框架通过ViewResolver来解析视图并且返回一个View对象,最后调用View的render方法返回到客户端DispatcherServlet这是框架的控制器,是一个具体类,它通过运行时的上下文对象来初始化.控制器本身并不去控制流程,而只是是Controller的”控制器”,他只是把处理请求的责任委托给了对应的Controller. 控制器继承自抽象基类FrameworkServlet,它的属性webApplicationContext就代表着这个web程序上下文,而这个上下文对象默认实现就是从一个XML文件读取配置信息(当然也可以是其他文件格式). WebApplicationContext其实是beans包的东西,这个包提供了这个Spring整个框架的基础结构,以后我会分析这个包的内容.但是现在仅仅需要知道WebApplicationContext代表一个web应用的上下文对象. 现在来看看DispatchServlet是如何工作的:DispatchServlet由于继承自抽象基类FrameworkServlet,而FrameworkServlet里的doGet(),doPost()方法里有调用serviceWrapper(),跳到serviceWrapper()里去看,结果发现它有把具体实现委托给了doService(request, response); 方法.所以现在已经很清楚了, DispatchServlet真正实现功能的是doService() 这个方法. 特别的, FrameworkServlet的initFrameworkServlet()这个方法是控制器的初始化方法,用来初始化HandlerMappings之类的对象,这也是延迟到子类实现的.其实就是一个Template模式的实现.don"t call us, we will call u.总的看来,Spring就是通过这样来实现它的控制反转的:用框架来控制流程,而不是用户 跳到doService()一看究竟,就会发现真正工作的又是另一个助手函数doDispatch(request, response),没办法,继续看下去,发现这样两行代码HandlerExecutionChain mappedHandler = null; mappedHandler = getHandler(processedRequest, false);看HandlerExecutionChain源码就发现它其实就是对Controller和它的Interceptors的进行了包装; getHandler()就是从HandlerMappings(这是一个List,存放的handlerMapping对象)中取出对应的handlerMapping对象, 每个HandlerMapping对象代表一个Controller和URL的映射(其实在运行的时候是一个HandlerExecutionChain和URL的映射,而HandlerExecutionChain对象其实就是对Controller和它interceptors的一个包装器,可以把HandlerMapping看成Controller和URL的映射).而这个HandlerMapping是通过配置文件在运行时注射进来的,一般是SimpleUrlHandlerMapping这个子类 取得了HandlerMapping对象,继续向下看,发现: if (mappedHandler.getInterceptors() != null) { for (int i = 0; i < mappedHandler.getInterceptors().length; i++) { HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i]; if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) { triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null); return; } interceptorIndex = i; } }这里就是在调用Controller的拦截器,原理就是这句了: interceptor.preHandle(processedRequest, response, mappedHandler.getHandler(), mv);preHandle方法传入了mappedHandler.getHandler()这个参数来实现递归调用!而interceptor.postHandle方法如此一般.只不过这个方法是在handleRequest方法后调用 继续看下去: HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); mv = ha.handle(processedRequest, response, mappedHandler.getHandler());发现Controller的handleRequest真正的操作又被代理给了HandlerAdapter的handle方法,并且返回一个ModelAndView,我想这里增加一层的意义应该是为了解除Controller和DispatchServlet的耦合吧. 接着就很简单了,调用render()方法,在这个方法里面由ViewResoler解析出视图名,再调用视图对象的render方法把合适的视图展现给用户 到此,控制器的流程就OVER了HandlerMapping通过使用HandlerMapping,控制器可以用URL和某一个Controller进行标准的映射,而实现URL映射的具体子类的UrlHandlerMapping. Spring还允许我们自定义映射,比如通过Session,cookie或者用户状态来映射.而这一切仅仅只需要实现HandlerMapping接口而已.不过URL映射已经能满足大部分的要求ControllerController 类似Structs的Action, Controller接口只有一个方法handleRequest(),放回一个ModelAndView对象,如同设计目标所说的那样,每个Controller都是一个java组件,所以它可以在上下文环境中任意配置,组件属性都会在初始化的时候被配置.Spring自己提供了几个具体的实现.方便我们使用ViewResolverController通常返回包含视图名字而不是视图对象的ModelAndView对象.从而彻底的解除了控制器和视图之间的耦合关系,并且在这里还可以提供国际化的支持.在你的配置文件中你可以:welcomeView.class = org.springframework.web.servlet.view. InternalResourceViewwelcomeView.url=/welcome.jsp也可以welcomeView.class = org.springframework.web.servlet.view.xslt. XsltViewwelcomeView.url=/xslt/default.xslt View这也是一个java组件,它不做任何请求处理或是业务逻辑,它仅仅获取模型传递的数据,并把数据显示出来.它里面的 render方法按照如下流程工作:l 设置模型的数据到request作用域l 取得视图的URLl 转发到对应的URL总结:Spring的web框架是一个很优秀的框架,在这里只是走马观花的分析了Spring的工作流程和一些关键的类,但是并没有去深入的去探讨它背后所体现的思想,还有它的优缺点等东西.这些都等下次再说吧

1、用script标签包围，然后像xml语法一样书写@Select({"<script>", "SELECT * FROM tbl_order", "WHERE 1=1", "<when test="title!=null">", "AND mydate = #{mydate}", "</when>", "</script>"})2、用Provider去实现SQL拼接，例如：public class OrderProvider { private final String TBL_ORDER = "tbl_order"; public String queryOrderByParam(OrderPara param) { SQL sql = new SQL().SELECT("*").FROM(TBL_ORDER); String room = param.getRoom(); if (StringUtils.hasText(room)) { sql.WHERE("room LIKE #{room}"); } Date myDate = param.getMyDate(); if (myDate != null) { sql.WHERE("mydate LIKE #{mydate}"); } return sql.toString(); }}public interface OrderDAO { @SelectProvider(type = OrderProvider.class, method = "queryOrderByParam") List<Order> queryOrderByParam(OrderParam param);}注意：方式1有个隐患就是当传入参数为空的时候，可能会造成全表查询。复杂SQL用方式2会比较灵活（当然，并不建议写复杂SQL），而且可以抽象成通用的基类，使每个DAO都可以通过这个基类实现基本的通用查询，原理类似Spring JDBC Template。

因为他手里拿着大把的进入仓库的令牌，他给你一个你就能进去，出来后你还给他，他再接着可以给下一个人，这个时候我们仓库门是一直打开的状态，省去了大把我们开锁、开门、关门、锁门的操作，完全交由一个专业人士管理，更神奇的是他还能记录你的一系列操作。对于tomcat的崇敬之情让我决定深入其中，一探究竟。于是我找到了网上大家首推的教材——《深入剖析tomcat》，书比较老，但是很权威，不影响原理性东西的理解。目前已经看到第二章。一个算法对其每一个输入的实例，都能输出正确的结果并停止，则称它是正确的，我们说一个正确的算法解决了给定的计算问题。不正确的算法对于某些输入来说，可能根本不会停止，或者停止时给出的不是预期的结果。然而，与人们对不正确算法的看法想反，如果这些算法的错误率可以得到控制的话，它们有时候也是有用的。但是一般而言，我们还是仅关注正确的算法！这两个框架的作者是园区里面的江大渔。 首先感谢他的无私开源贡献。之所以要写这个文章是因为群里经常有人问这个客户端框架要如何使用。原因在于服务端框架的文档比较多，客户端的文档比较少，所以很多c#基础比较差的人就不懂怎么玩起来。今天就这里写一个例子希望能给部分人抛砖引玉吧。http://www.cnblogs.com/gutye/ 代理接口方式，我们姑且不管是怎么样代理的，但能够运行起来，肯定是有一段真正的可以运行的代码——实际上就是调用SqlSession接口中的方法。因此首先需要解决的就是下面三个基本问题：配置base指定模板目录可以缩短模板的路径，并且能够避免include语句越级访问任意路径引发安全隐患但是随着项目上线后，发现业务数据越来越多，查询效率越来越慢，这时就需要分析慢查询记录了。如何开启慢查询记录？就是本篇文章介绍的内容了。http://www.cnblogs.com/jrtjwe/ 从表现层来看，Spring MVC用了逻辑命名视图策略，通过引入ViewResolver和View，清晰分离了视图策略的选择和渲染与具体控制器之间的耦合，适合各种视图技术很容易集成到Spring MVC中，不管是JSP/JSTL作为视图技术，还是Velocity/FreeMarker，甚至是PDF/Excel等二进制格式视图形式，使用它们，只需要简单的配置。这个对象最早在IE中被实现，不过它最早的时候是通过ActiveXObject实现的，如果不需要管兼容的话，IE9或者其他浏览器使用 new XMLHttpRequest() 就能创建了一个 XHR (XMLHttpRequest) 对象,IE中由于存在三个版本的XHR对象，所以如果需要兼容，需要对这三个版本进行处理，从中选出IE浏览器中最新支持对象。在大部分 .Net 开发人心目中，好像并没有数据库连接池的概念，只有数据库连接，然后用完要记得close和用using，在 Java 中有太多的开源的数据库连接池，而且好像一个吹的比一个厉害。我其实告诉你，其实在 .Net 中 ADO.Net 已经帮我们实现了数据库连接池，我们并不需要什么配置，用就是了，但 Java 不一样，需要我们自己选择合适的数据库连接池。下面我说说项目中为什么选择了阿里的 Druid 数据库连接池。sqlId，Mybatis怎么确定需要执行的方法标签：

可以看看《深入浅出MyBatis技术原理与实战》

举个例子来研究一下。

mybatis预编译底层实现原理 MyBatis何做SQL预编译呢其实框架底层JDBCPreparedStatement类起作用PreparedStatement我熟悉Statement类象包含编译SQL语句种准备式仅能提高安全性且执行同SQL能够提高效率原SQL已编译再执行需再编译总结 #{}：相于JDBCPreparedStatement ${}：输变量值 简单说#{}经预编译安全；${}未经预编译仅仅取变量值非安全存SQL注入希望帮助~-

现象1：如果使用原生mybatis进行数据操作，那么必须按照以下方式使用：SqlSession sqlSession = null;try { sqlSession = sqlSessionFactory.openSession(); //namespace+id sqlSession.insert("cn.jarjar.dao.BlogMapper.insertBlog", blog); sqlSession.commit(true)} catch (Exception e) { e.printStackTrace(); sqlSession.rollback(true);} finally { sqlSession.close();}也就是要像原始的java.sql.Connection对象一样，必须按照：新建连接->执行SQL->提交（查询不需要）->如果操作数据存在异常需要回滚->释放数据库连接。注意第一点和最后一点，每个SqlSession新建之后必须释放，不然会造成数据库连接泄露的危险。也就是意味着SqlSession是个有状态的对象，是无法进行复用的，所以只能局限于request或者方法的范围，也就是所谓的线程不安全。现象2：如果使用spring集成mybatis，官方提供了整和包mybatis-spring.jar，如果完成配置之后，使用方式及其简单，简单示例如下：//注入spring中配置的SqlSessionTemplate对象，单例@Resource(name="sqlSessionTemplate")public SqlSessionTemplate sqlSessionTemplate;public void saveTestTrans(){ this.sqlSessionTemplate.selectList("testdomain.selectAnySql", "select * from my_blog where id="1"");}这里的SqlSessionTemplate不仅是单例的，而且不需要手工新建和关闭SqlSession问题1：那么问题来了，为什么mybatis-spring.jar中的SqlSessionTemplate可以被多个dao复用，而且不会造成数据连接泄露呢，并且还可以自动新建和释放数据库连接看官方解答是因为SqlSessionTemplate是线程安全的，也就是确保每个线程使用的sqlSession的唯一并不互相冲突。首先看了一下mybatis-spring的源码，发现SqlSessionTemplate是通过代理拦截和SqlSessionHolder实现的sqlsession线程安全和自动新建和释放连接的。看构造函数函数中构建代理类，该代理类实现SqlSession接口，定义了方法拦截器，如果调用代理类实例中实现SqlSession接口定义的方法，该调用则被导向SqlSessionInterceptor的invoke方法，这个方法中自动进行了SqlSession的自动请求和释放（如果不被spring托管则自己新建和释放sqlsession，如果被spring管理则使用SqlSessionHolder进行request和relase操作）以下网址针对SqlSessionTemplate的线程安全特性进行了详细的探究：问题2：然后又想到这样一个问题，虽然现在几乎所有项目都使用spring作为java程序的基本框架，如果我不使用spring管理mybatis，仅仅使用原始的mybatis，怎么样才能构建一个和SqlSessionTemplate相似的对象呢看首先想到必须使用java的treadLocal构建一个sqlsession的对象，如ThreadLocal sqlSession = new ThreadLocal()。经过查找，发现mybatis自身就有这样一个类实现了类似的功能，类路径：org.apache.ibatis.session.SqlSessionManager，但是没有注释，可能存在mybatis-spring这种神器之后，mybatis放弃了对这个类的维护。该类实现了SqlSessionFactory, SqlSession并且在其中定义了一个treadLocal的sqlssion对象，同时使用了代理拦截进行了sqlsession的自动管理，具体代码可以自己查阅，对于理解mybatis原理和java的代理机制很有帮助。那么写个简单的程序验证一下SqlSessionManager是否真的可以保证线程安全和自动新建和释放sqlssion：TestSqlManager.javaprivate static SqlSession sqlSession;public static SqlSession getSqlSessionTest(){ if(sqlSession == null){ //构建使用的SqlSessionFactory SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory(); sqlSession = SqlSessionManager.newInstance(sqlSessionFactory); } return sqlSession;}public static void main(String[] args) throws InterruptedException { Run run = new Run(); List threads = new ArrayList (); for (int i = 0; i < 100; i++) { Thread t = new Thread(run); threads.add(t); System.out.println("thread:{"+t.getName()+"}, start"); t.start(); } for (Thread t : threads) { System.out.println("thread:{"+t.getName()+"},join"); t.join(); }}我本机装的mysql，通过监控语句：select SUBSTRING_INDEX(host,":",1) as ip , count(*) from information_schema.processlist group by ip;发现执行过程中存在连接并发的情况，但是执行之后全部释放掉了。

MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。用xml文件构建SqlSessionFactory实例是非常简单的事情。mybatis的功能构架：1、API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。2、数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。用xml文件构建SqlSessionFactory实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但你可以使用任何Reader实例，包括用文件路径或file://开头的url创建的实例。MyBatis有一个实用类----Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。把Mybatis的功能架构分为三层：1、API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。2、数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。3、基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

查询语句是 MyBatis 中最常用的元素之一，本文涉及mybatis的单表查询操作，关联表有关的查询会后续补充。 巧妇难为无米之炊，要想从数据库中表中取出数据并转化为javaBean，所以，我们要先准备javabean以及与其对应的数据表。javaBean：public class President { private int id; private String name; @Override public String toString() { return "President [id=" + id + ", name=" + name + "]"; } //get set 方法.....}创建两个对应的数据库表，并插入两条数据：create table president1( p_id int not null auto_increment primary key, p_name varchar(50) not null);insert into president1(p_name) values("lily"),("Tom");create table president2( id int not null auto_increment primary key, name varchar(50) not null);insert into president2(name) values("lily"),("Tom");创建两个数据库是为了测试两个不同的查询状况，数据库字段名与实体类属性名相同从sql表可以看出president2的字段名与javabean：President的属性名完全相同，这种情况下mybatis的select操作非常简单：<!-- 从表 president2中查询--> <select id="getPreByIdPresident2" parameterType="int" resultType="President"> select * from president2 where id=#{id} </select>此时mybatis运用反射机制会将查询返回的结果(id,name)封装成President对象。如果从表president1中查询，同样采用上面的sql语句<!-- 从表 president1中查询--> <select id="getPreByIdPresident1" parameterType="int" resultType="President"> <span style="white-space:pre"> </span>President p1 = session.selectOne(statement+"getPreByIdPresident1", 1);<span style="white-space:pre"> </span>System.out.println("表president1中查询"+p1); </select>此时如果用getPreByIdPresident1进行查询，返回的结果会是null，我们将上面的sql语句在mysql中执行下：有结果返回，但是返回的字段名为(p_id,p_name)这种结果mybatis在解析时无法与President类对应。多数情况下实体类属性名与数据库表的字段名都会有差异，这种情况如果mybatis不能处理也就太low了。数据库字段名与实体类属性名不相同mybatis针对该种情况有两种解决方法，但是归根到底都是同一种实现。Method1：定义一个ResultMap将数据库字段名与实体类属性名做个映射我们欲从表president1中查询数据，此时的mapper配置如下：<resultMap type="President" id="getFromPresident2"> <!-- 主键必须用id标签映射，其他的用非集合用result映射 集合类用collection映射 --> <!-- column为数据库字段名,property为实体类属性名 --> <id column="p_id" property="id" /> <result column="p_name" property="name" /> </resultMap> <select id="getPreByIdPresident1Method1" resultMap="getFromPresident2"> select * from president1 where p_id=#{id} </select>首先定义了一个resultMap，将数据库表的字段名与实体类属性名做了一一对应，其中type为实体类(此处运用的类别名)，id为了在select标签中引用映射结果。在select标签中并没有用resultType属性，而使用了resultMap，即为上面定义的resultMap，mybatis会根据resultMap中的映射关系去构造PresidentMethod1：直接在sql语句中使用别名 <!-- 从表 president1中查询 --> <select id="getPreByIdPresident1Method2" resultType="President"> select p_id id,p_name name from president1 where p_id=#{id} </select>这种方法会查到实际的数据，这种方法与字段名和属性名相同都是基于相同的原理：MyBatis 会在幕后自动创建一个 ResultMap,基于属性名来映射列到JavaBean 的属性上。即mybatis底层都是通过创建ResultMap来进行关系的映射，与method1原理相同。。

具体方法一般要检查配置文件命名空间，还有applicationContext.xml里的配置<bean id ="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"p:dataSource-ref="dataSource" p:configLocation="classpath:mybatis-config.xml"><property name="mapperLocations"><list><value>classpath*:com/xxx/**/*Mapper.xml</value></list></property></bean>

引入了以下包 其中自动装配的包就是mybatis-spring-boot-autoconfigure。 META-INF下有一个spring.factories文件 导入了这个类MybatisAutoConfiguration 注册MapperScannerConfigurer的Bean定义到Spring容器中,并设置扫描包的路径 MapperScannerConfigurer 实现BeanDefinitionRegistryPostProcessor接口,实例化的时候会调到postProcessBeanDefinitionRegistry方法,这个方法里会创建一个ClassPathMapperScanner对象,然后去扫描 扫描到之后修改BeanDefinition @MapperScan注解，会import进来MapperScannerRegistrar这个类 MapperScannerRegistrar类实现ImportBeanDefinitionRegistrar接口,实例化的时候会调用registerBeanDefinitions方法 和@Mapper一样，同样会创建MapperScannerConfigurer的BeanDefition,用于后续实例化 只不过要扫描的包路径变了，不再是默认的,而是@MapperScan配置的包路径 后面的话则和@Mapper扫描到之后的工作原理是一样的,扫描到之后，更改BeanDefinition，一毛一样的。 ==可以看出@MapperScan最主要的工作原理除了提供BasePackage的值之外,就是用@Import注解导入MapperScannerRegistrar.所以这个注解打在任何可以被spring扫描到的类上都可以,并不一定要打在启动类上(大多数为了只是为了看起来方便，把全局性的配置注解打在启动类上而已)== 前面提到,注册扫描@Mapper接口的MapperScannerConfigurer实例的类是AutoConfiguredMapperScannerRegistrar,那么这个类是如何被导入进来的呢 MybatisAutoConfiguration还有一个静态内部类,@Import了AutoConfiguredMapperScannerRegistrar类,但是有@ConditionalOnMissingBean,即spring容器中不存在MapperFactoryBean,MapperScannerConfigurer的实例。 如果@MapperScan注解生效,并且扫描到任意一个Mapper接口(前面被改造成MapperFactoryBean类型的了)，那么就不满足注册这个类MapperScannerRegistrarNotFoundConfiguration的实例的条件，继而不会导入AutoConfiguredMapperScannerRegistrar类。 前面提到,所有的Mapper接口被扫描到,封装成BeanDefinition,还经历了一次改造, 最主要的就是将mapper接口BeanDefination的beanClass改成了org.mybatis.spring.mapper.MapperFactoryBean.class 并且将mapper接口BeanDefination的名称作为构造函数的入参传入进去 并讲BeanDefinition的autowireMode属性改成 AUTOWIRE_BY_TYPE ,后面实例化该bean的时候会调用属性的描述器,用write的方式注入属性值，最重要的那个属性那就是SqlSessionTemplate. 会通过这种方式将前面MybatisAutoConfiguration中@Bean出来的SqlSessionTemplate注入到其中。 类图： 这里他实现了FactoryBean, FactoryBean有以下方法 这里是spring的一个拓展点,实现了FactoryBean接口的类,将可以实现getObject() 和getObjectType来实例化额外的一个bean并装到spring容器中 好吧,其实Mapper代理对象的创建就是在MapperFactoryBean的getObject方法中返回的 这里就是熟悉的原生Mybatis创建Mapper接口的味道了。 附上调用的类时序图,回过头来看一下调用的整体流程。

笔者只能说会使用Mybtis，并没有具体研究过源码，站在一个使用者的角度记录解决的问题。 跳过大部分源码，从一个功能点开始入手。 以 Select 操作为例，研究如何获取经过 Mybatis 中 动态语句 转换后的的 SQL语句 。 我们这里不涉及复杂的过程原理（如：读取配置文件、Mapper代理等（ 我也不懂 ）），只说明一下具体流程。 发现studentMapper被MapperProxy实现。 好奇的同学肯定会问studentMapper是如何创建MapperProxy实例的呢？ 一路跟随瞎点。会发现一个配置类，里面东西很多，目前只看和Mapper有关系。 我们继续下一步 到此关于Mapper的运行过程已经分析完了，下面继续分析SelectOne过程。 selectOne 其实只是 selectList 取第一个元素（这点是没有想到的）。 源码解析，这还是第一次写这类文章，确实这些框架的原理，并没有研究过只是知道一点概念，Mapper动态代理之类的。网上的博客从大方向出发，框架设计、设计模式之类的，对于我这种基础薄弱的人看的云里雾里。我准备从一个一个功能开始初步了解、研究此类框架原理。 参考 https://blog.csdn.net/luanlouis/article/details/40422941

KeyWords: Mybatis 原理，源码，Mybatis Mapper 接口实现类，代理模式，动态代理，Java动态代理，Proxy.newProxyInstance，Mapper 映射，Mapper 实现 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。我们在使用 Mybaits 进行 ，通常只需要定义几个 Mapper 接口，然后在编写一个 xml 文件，我们在配置文件中写好 sql , Mybatis 帮我们完成 Mapper 接口道具体实现的调用。以及将结果映射到 model bean 中。 我们在项目中所编写的众多的 Mapper 类只是一个接口(interface )，根据 Java 的多态性我们知道，可以使用接口接口作为形参，进而在运行时确定具体实现的对象是什么。但是，对于 Mapper 接口，我们并没有编写其实现类！Mybatis是如何找到其实现类，进而完成具体的 CRUD 方法调用的呢？原理何在？ 为了弄清楚 Mapper 接口是如何找到实现类的，我们先回忆一下 Mybatis 是怎么使用的，根据实际的例子，进而一点点的去分析。这里的使用指的是Mybatis 单独使用，而不是整合 spring , 因为整合 spring 的话，还需要涉及 Mapper dao 装载到 spring 容器的问题，spring 帮忙创建数据源配置等问题。 通常我们使用 Mybatis 的主要步骤是： 从一段代码看起 上面我们概括了使用 Mybatis 的4个步骤。这4个步骤看起来很简单，但是用代码写出来就很多。我们不妨先记着这4个步骤，再去看代码，会容易点。 在这块代码中，第 1 部分我们使用了 Java 编码的形式来实现 SqlSessionFactory ，也可以使用 xml 。如果使用xml的话，上面的第一部分代码就是这样的： 我们本次的目标是弄清楚 “ Mapper 是如何找到实现类的 ”，我们注意上面代码 3 , 4 的位置： 这里 mapper 可以调用selectBlog(1) 这个方法，说明 mapper 是个对象，因为对象才具有方法行为实现啊。BlogMapper接口是不能实例化的，更没有具体方法实现。我们并没有定义一个类，让它实现BlogMapper接口，而在这里它只是通过调用session.getMapper() 所得到的。由此，我们可以推断：肯定是session.getMapper() 方法内部产生了BlogMapper的实现类。有什么技术可以根据BlogMapper 接口生成了一个实现类呢？想到这里，对于有动态代理 使用经验的程序员来说，很容易想到，这背后肯定是基于动态代理技术，具体怎么实现的呢？下面我们来根据源码一探究竟。 Mapper 接口的注册 从上面的代码中，我们知道 BlogMapper 接口的实现类是从session.getMapper中得来的，大概是基于动态代理技术实现。我们既然能够从SqlSession中得到BlogMapper接口的，那么我们肯定需要先在哪里把它放进去了，然后 SqlSession 才能生成我们想要的代理类啊。上面代码中有这么一行： 跟着这个 addMapper 方法的代码实现是这样的： 我们看到这里 mapper 实际上被添加到 mapperRegissry 中。继续跟进代码： 看到这里我们知道上面所执行的configuration.addMapper(BlogMapper.class); 其实最终被放到了HashMap中，其名为knownMappers ，knowMappers是MapperRegistry 类的一个私有属性，它是一个HashMap 。其Key 为当前Class对象，value 为一个MapperProxyFactory 实例。 这里我们总结一下： 诸如BlogMapper 之类的Mapper接口被添加到了MapperRegistry 中的一个HashMap中。并以 Mapper 接口的 Class 对象作为 Key , 以一个携带Mapper接口作为属性的MapperProxyFactory 实例作为value 。MapperProxyFacory从名字来看，好像是一个工厂，用来创建Mapper Proxy的工厂。我们继续往下看。 Mapper接口的动态代理类的生成 上面我们已经知道，Mapper 接口被到注册到了MapperRegistry中——放在其名为knowMappers 的HashMap属性中，我们在调用Mapper接口的方法的时候，是这样的： 这里，我们跟踪一下session.getMapper() 方法的代码实现，这里 SqlSession 是一个接口，他有两个实现类，一个是DefaultSqlSession,另外一个是SqlSessionManager,这里我们用的是DefaultSqlSession. 为什么是DefaultSqlSession呢？因为我们在初始化SqlSessionFactory的时候所调用的SqlSessionFactoryBuilder的build()方法里边配置的就是DefaultSqlSession, 所以，我们进入到DefaultSession类中，看看它对session.getMapper(BlogMapper.class)是怎么实现的： 如代码所示，这里的 getMapper 调用了 configuration.getMapper , 这一步操作其实最终是调用了MapperRegistry,而此前我们已经知道，MapperRegistry是存放了一个HashMap的，我们继续跟踪进去看看，那么这里的get，肯定是从这个hashMap中取数据。我们来看看代码： 我们调用的session.getMapper(BlogMapper.class);最终会到达上面这个方法，这个方法，根据BlogMapper的class对象,以它为key在knowMappers 中找到了对应的value —— MapperProxyFactory(BlogMapper) 对象，然后调用这个对象的newInstance()方法。根据这个名字，我们就能猜到这个方法是创建了一个对象，代码是这样的： 看到这里，就清楚了，最终是通过Proxy.newProxyInstance产生了一个BlogMapper的代理对象。Mybatis 为了完成 Mapper 接口的实现，运用了代理模式。具体是使用了JDK动态代理，这个Proxy.newProxyInstance方法生成代理类的三个要素是： 代理模式中，代理类(MapperProxy)中才真正的完成了方法调用的逻辑。我们贴出MapperProxy的代码，如下： 我们调用的 Blog blog = mapper.selectBlog(1); 实际上最后是会调用这个MapperProxy的invoke方法。这段代码中，if 语句先判断，我们想要调用的方法是否来自Object类，这里的意思就是，如果我们调用toString()方法，那么是不需要做代理增强的，直接还调用原来的method.invoke()就行了。只有调用selectBlog()之类的方法的时候，才执行增强的调用——即mapperMethod.execute(sqlSession, args);这一句代码逻辑。 而mapperMethod.execute(sqlSession, args);这句最终就会执行增删改查了，代码如下： 再往下一层，就是执行JDBC那一套了，获取链接，执行，得到ResultSet，解析ResultSet映射成JavaBean。 至此，我们已经摸清楚了Blog blog = mapper.selectBlog(1); 中，BlogMapper接口调用到得到数据库数据过程中，Mybaitis 是如何为接口生成实现类的，以及在哪里出发了最终的CRUD调用。实际上，如果我们在调用Blog blog = mapper.selectBlog(1);之前，把从slqSession中得到的 mapper 对象打印出来就会看到，输出大概是这样的： 动态代理没错吧，Java动态代理实在是太美妙了。 上面我们用层层深入的方式摸清楚了 Mapper接口是如何找到实现类的。我们分析了 Mapper接口是如何注册的，Mapper接口是如何产生动态代理对象的，Maper接口方法最终是如何执行的。总结起来主要就是这几个点：

查资料了解到，surround back是接接环绕音箱。功放surround是指环绕声，环绕声扬声器系统一般会使用5个以上的扬声器，分别摆放在前、中、后三个位置，从而让扬声器环绕着听众摆放，这就是“环绕声”这个概念的由来。

在src的根目录下建一个struts-2.0.dtd（struts包里面有）和struts.xml，struts.xml里面配置常量和自己写的action的路径，在WEB-INF（WEB-ROOT）目录下建一个applicationContext.xml,在这里面配置事务管理器、事务通知、事务切点以及数据库的关联配置和bean文件的关联，还有在web.xml里面配置struts2的filter和filter-mapping

从命名上可以看出，这个是一个 Builder 模式的，用于创建 SqlSessionFactory 的类。SqlSessionFactoryBuilder 根据配置来构造 SqlSessionFactory。其中配置方式有两种： mybatis-config.xml 就是我们的配置文件: Java Config 相比较 XML 文件的方式而言，会有一些限制。比如修改了配置文件需要重新编译，注解方式没有 XML 配置项多等。所以，业界大多数情况下是选择 XML 文件的方式。但到底选择哪种方式，这个要取决与自己团队的需要。比如，项目的 SQL 语句不复杂，也不需要一些高级的 SQL 特性，那么 Java Config 则会更加简洁一点；反之，则可以选择 XML 文件的方式。 创建配置文件解析器XMLConfigBuilder 解析mybatis-config.xml里的配置为Configuration对象，Mybatis的全局配置对象。 XMLConfigBuilder#parseConfiguration解析mapper下的xml XMLMapperBuilder#bindMapperForNamespace，根据xml里的 namespace 反射出 mapper接口 的 class，如果有mapper接口，则把该mapper接口的class添加到Configuration的mapperRegistry里。 如果该接口已经注册，则抛出已经绑定的异常。 为该接口注册MapperProxyFactory，但这里只是注册其创建MapperProxy的工厂，并不是创建MapperProxy。 如果Mapper对应的xml资源未加载，触发xml的绑定操作，将xml中的sql语句与Mapper建立关系。 addMapper方法，只是为**Mapper创建对应对应的MapperProxyFactory。 根据Mapper接口与SqlSession创建MapperProxy对象。 根据接口类获取MapperProxyFactory。 调用MapperProxyFactory的newInstance创建MapperProxy对象。 SqlSessionFactory 顾名思义，是用于生产 SqlSession 的工厂。 通过如下的方式来获取 SqlSession 实例： SqlSession 包含了执行 SQL 的所有的方法。以下是示例： 当然，下面的方式可以做到类型安全： MapperProxy是MapperProxyFactory使用SqlSession创建出来的。所以MapperProxy中包含SqlSession。 可以看到MapperProxy调用invoke方法，进而调用MapperMethod的execute()，这些MapperMethod就是和你要执行的命令相关，比如执行select语句，则会通过SqlSession的select()方法，最终调用到Executor的query方法。Executor会再协调另外三个核心组件。 MapperProxy： MapperMethod： 插件的构建： 谈原理首先要知道StatementHandler，ParameterHandler，Result Handler都是代理，他们是Configuration创建，在创建过程中会调用interceptorChain.pluginAll()方法，为四大组件组装插件（再底层是通过Plugin.wrap(target,XX, new Plugin( interceptor))来来创建的）。 插件链是何时构建的： 在执行SqlSession的query或者update方法时，SqlSession会通过Configuration创建Executor代理，在创建过程中就调用interceptor的pluginAll方法组装插件。然后executor在调用doQuery()方法的时候，也会调用Configuration的newStatementHandler方法创建StatemenHandler（和上面描述的一样，这个handler就是个代理，也是通过interceptorChain的pluginAll方法构建插件） 插件如何执行： 以statementhandler的prepare方法的插件为例，正如前面所说，statementhandler是一个proxy，执行他的prepare方法，将调用invokeHandler的invoke方法，而invokeHandler就是Plugin.wrap(target, xxx, new Plugin(interceptor))中的第三个参数，所以很自然invokeHanlder的invoke的方法最终就会调用interceptor对象的intercept方法。 Mybatis的插件配置在configuration内部，初始化时，会读取这些插件，保存于Configuration对象的InterceptorChain中。 org.apache.ibatis.plugin.InterceptorChain.java源码。 上面的for循环代表了只要是插件，都会以责任链的方式逐一执行，所谓插件，其实就类似于拦截器。 插件的编写 插件必须实现org.apache.ibatis.plugin.Interceptor接口。 -intercept()方法：执行拦截内容的地方，拦截目标对象的目标方法的执行 -plugin()方法：决定是否触发intercept()方法。 作用：包装目标对象，包装就是为目标对象创建一个代理对象 -setProperties()方法：给自定义的拦截器传递xml配置的属性参数。将插件注册时的property属性设置进来 下面自定义一个拦截器： 为什么要写Annotation注解？注解都是什么含义？ Mybatis规定插件必须编写Annotation注解，是必须，而不是可选。@Intercepts注解：装载一个@Signature列表，一个@Signature其实就是一个需要拦截的方法封装。那么，一个拦截器要拦截多个方法，自然就是一个@Signature列表。 type = Executor.class, method = "query", args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class } 解释：要拦截Executor接口内的query()方法，参数类型为args列表。 Plugin.wrap(target, this)是干什么的？ 使用JDK的动态代理，给target对象创建一个delegate代理对象，以此来实现方法拦截和增强功能，它会回调intercept()方法。 Mybatis可以拦截哪些接口对象？ Mybatis只能拦截ParameterHandler、ResultSetHandler、StatementHandler、Executor共4个接口对象内的方法。 重新审视interceptorChain.pluginAll()方法：该方法在创建上述4个接口对象时调用，其含义为给这些接口对象注册拦截器功能，注意是注册，而不是执行拦截。 拦截器执行时机：plugin()方法注册拦截器后，那么，在执行上述4个接口对象内的具体方法时，就会自动触发拦截器的执行，也就是插件的执行。 Invocation 可以通过invocation来获取拦截的目标方法，以及执行目标方法。 分页插件原理 由于Mybatis采用的是逻辑分页，而非物理分页，那么，市场上就出现了可以实现物理分页的Mybatis的分页插件。 要实现物理分页，就需要对String sql进行拦截并增强，Mybatis通过BoundSql对象存储String sql，而BoundSql则由StatementHandler对象获取。 因此，就需要编写一个针对StatementHandler的query方法拦截器，然后获取到sql，对sql进行重写增强。

你好，很高兴回答你的问题。mybatis分页插件是通过在你写好的sql语句基础上，拼接生成两个sql语句实现的。第一个是以你的sql作为子查询进行count的语句，用来查询符合条件是数据总条数。另一个是在你的sql的基础上拼接了limit进行分页查询。如果有帮助到你，请点击采纳。我解答的大部分是软件开发新人遇到的问题，如果有兴趣可以关注我。

在介绍Spring整合Mybatis原理之前，我们得先来稍微介绍Mybatis的工作原理。 在Mybatis中，我们可以使用一个接口去定义要执行sql，简化代码如下： 定义一个接口，@Select表示要执行查询sql语句。 以下为执行sql代码： Mybatis的目的是：使得程序员能够以调用方法的方式执行某个指定的sql，将执行sql的底层逻辑进行了封装。 这里重点思考以下mapper这个对象，当调用SqlSession的getMapper方法时，会对传入的接口生成一个 代理对象，而程序要真正用到的就是这个代理对象，在调用代理对象的方法时，Mybatis会取出该方法所对应的sql语句，然后利用JDBC去执行sql语句，最终得到结果。 UserService中的userMapper属性就会被自动注入为Mybatis中的代理对象。如果你基于一个已经完成整合的项目去调试即可发现，userMapper的类型为： org.apache.ibatis.binding.MapperProxy@41a0aa7d。证明确实是Mybatis中的代理对象。 好，那么现在我们要解决的问题的就是：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？要解决这个，我们需要对Spring的bean生成过程有一个了解。 Spring启动过程中，大致会经过如下步骤去生成bean 假设有一个A类，假设有如下代码： 一个A类 一个B类，不存在@Component注解 执行如下代码： 输出结果为：com.luban.util.A@6acdbdf5 A类对应的bean对象类型仍然为A类。但是这个结论是不确定的，我们可以利用BeanFactory后置处理器来 修改BeanDefinition，我们添加一个BeanFactory后置处理器： 这样就会导致，原本的A类对应的BeanDefiniton被修改了，被修改成了B类，那么后续正常生成的bean对 象的类型就是B类。此时，调用如下代码会报错： 但是调用如下代码不会报错，尽管B类上没有@Component注解： 并且，下面代码返回的结果是：com.luban.util.B@4b1c1ea0 之所以讲这个问题，是想说明 个问题：在Spring中，bean对象跟class没有直接关系，跟 BeanDefinition才有直接关系。 那么回到我们要解决的问题：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？ 在Spring中，如果你想生成一个bean，那么得先生成一个BeanDefinition，就像你想new一个对象实 例，得先有一个class。 继续回到我们的问题，我们现在想自己生成一个bean，那么得先生成一个BeanDefinition，只要有了 BeanDefinition，通过在BeanDefinition中设置bean对象的类型，然后把BeanDefinition添加给 Spring，Spring就会根据BeanDefinition 动帮我们 成 个类型对应的bean对象。 所以，现在我们要解决两个问题： 注意：上文中我们使用的BeanFactory后置处理器，他只能修改BeanDefinition，并不能新增一个 BeanDefinition。我们应该使用Import技术来添加一个BeanDefinition。后面再详细介绍如果使用Import 技术来添加一个BeanDefinition，可以先看一下伪代码实现思路。 假设：我们有一个UserMapper接口，他的代理对象的类型为UserMapperProxy。 那么我们的思路就是这样的，伪代码如下： 但是，这里有一个严重的问题，就是上文中的UserMapperProxy是我们假设的，他表示一个代理类的类 型，然而Mybatis中的代理对象是利用的JDK的动态代理技术实现的，也就是代理对象的代理类是动态生成的，我们根本方法确定代理对象的代理类到底是什么。 所以回到我们的问题：Mybatis的代理对象的类型是什么？ 本来可以有两个答案： 1. 代理对象对应的代理类 2. 代理对象对应的接口 那么答案1就相当于没有了，因为是代理类是动态生成的，那么我们来看答案2：代理对象对应的接口如果我们采用答案2，那么我们的思路就是： 但是，实际上给BeanDefinition对应的类型设置为一个接口是行不通的，因为Spring没有办法根据这个 BeanDefinition去new出对应类型的实例，接口是没法直接new出实例的。 那么现在问题来了，我要解决的问题：Mybatis的代理对象的类型是什么？ 两个答案都被我们否定了，所以这个问题是无解的，所以我们不能再沿着这个思路去思考了，只能回到最 开始的问题：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？ 总结上文的推理：我们想通过设置BeanDefinition的class类型，然后由Spring自动的帮助我们去生成对应的bean，但是这条路是行不通的。 终极解决方案 那么我们还有没有其他办法，可以去生成bean呢？并且生成bean的逻辑不能由Spring来帮我们做了，得 由我们自己来做。 FactoryBean 有，那就是Spring中的FactoryBean。我们可以利用FactoryBean去自定义我们要生成的bean对象，比如 我们定义了一个LubanFactoryBean，它实现了FactoryBean，getObject方法就是用来自定义生成bean 对象逻辑的。 执行如下代码： 将打印： lubanFactoryBean: com.luban.util.LubanFactoryBean 1@4d41cee &lubanFactoryBean: com.luban.util.LubanFactoryBean@3712b94 lubanFactoryBean-class: class com.sun.proxy. Proxy20 从结果我们可以看到，从Spring容器中拿名字为"lubanFactoryBean"的bean对象，就是我们所自定义的 jdk动态代理所生成的代理对象。 所以，我们可以通过FactoryBean来向Spring容器中添加一个自定义的bean对象。上文中所定义的 LubanFactoryBean对应的就是UserMapper，表示我们定义了一个LubanFactoryBean，相当于把 UserMapper对应的代理对象作为一个bean放入到了容器中。 但是作为程序员，我们不可能每定义了一个Mapper，还得去定义一个LubanFactoryBean，这是很麻烦的 事情，我们改造一下LubanFactoryBean，让他变得更通用，比如： 改造LubanFactoryBean之后，LubanFactoryBean变得灵活了，可以在构造LubanFactoryBean时，通 过构造传入不同的Mapper接口。 实际上LubanFactoryBean也是一个Bean，我们也可以通过生成一个BeanDefinition来生成一个 LubanFactoryBean，并给构造方法的参数设置不同的值，比如伪代码如下： 特别说一下注意二，表示表示当前BeanDefinition在生成bean对象时，会通过调用LubanFactoryBean的 构造方法来生成，并传入UserMapper的Class对象。那么在生成LubanFactoryBean时就会生成一个 UserMapper接口对应的代理对象作为bean了。 到此为止，其实就完成了我们要解决的问题：把Mybatis中的代理对象作为一个bean放入Spring容器中。 只是我们这是用简单的JDK代理对象模拟的Mybatis中的代理对象，如果有时间，我们完全可以调 Mybatis中提供的方法区生成一个代理对象。这里就不花时间去介绍了。 Import 到这里，我们还有一个事情没有做，就是怎么真正的定义一个BeanDefinition，并把它添加到Spring中， 上文说到我们要利用Import技术，比如可以这么实现： 定义如下类： 并且在AppConfig上添加@Import注解： 这样在启动Spring时就会新增一个BeanDefinition，该BeanDefinition会生成一个LubanFactoryBean对 象，并且在生成LubanFactoryBean对象时会传入UserMapper.class对象，通过LubanFactoryBean内部 的逻辑，相当于会自动生产一个UserMapper接口的代理对象作为一个bean。 总结一下，通过我们的分析，我们要整合Spring和Mybatis，需要我们做的事情如下： 作者：程序员周瑜 链接：https://juejin.cn/post/7089023062800236552

mybatis篇 一级缓存的作用域是Sqlsession级别的，也就是说不同的Sqlsession是不会走一级缓存的，那么如果需要跨Sqlsession的缓存，就需要使用到二级缓存了。 二级缓存的话默认是关闭的，所以需要我们开启，开启的方式官网也有介绍,需要在mybatis-config.xml核心配置文件中开启二级缓存功能，并且我们mapper.xml中也需要加入<cache/>标签，二者缺一不可，后面我们看源码就能知道为啥这两个缺一不可。 先来看个例子 执行结果很意外，为什么二级缓存的功能都开启了，结果sql还是执行了2次，并没有走缓存，其实，二级缓存还有一个要注意的点那就是必须要提交事务二级缓存才会保存记录，因为已经是跨SqlSession共享缓存了，所以事务必须要提交，否则会读取到因混滚导致的错误数据。 有个地方需要注意，二级缓存的Sqlsession中的Executor实际上是CachingExecutor 我们知道getMapper最终的执行都会走到MapperProxy类中的invoker方法，具体就来分析这个类。 最后来到了重点的地方 CacheKey我们可以认为他就是每个方法对应的一个唯一标识符。 这里我们就可以看出为什么之前两者必须要配置，cacheEnable开启了才会用CachingExecutor包装一下BaseExecutor，而<cache/>标签只有配置了才会走缓存的逻辑 这里的tcm 到这，我们就差不多揭开了二级缓存的秘密，重要的还是<cache/>这个标签，因为它的存在就对应着每个mapper.xml中的一个具体Cache类，而这个类在每个mapper.xml中又是同一个，所以最终的值是放入了Cache类中，key为CacheKey，value就是sql执行的结果。 至于为什么需要事务提交才能命中二级缓存，我们看下put方法就知道 这里的putObject并没有真正的把值存入Cache中，而是存入了待提交的Map中，所以再来看下commit做了什么 具体看tcm.commit() 而这里可以看到此处会遍历所有的TransactionCache并执行commit方法 真相就出来了，会遍历待提交的Map然后把里面的值都存入Cache中，所以后面的查询就能直接从Cache中拿到值了。 总结 二级缓存先会把Sqlsession中的Executor包装成包装成CacheingExecutor,所有的sql都会经过这个类，而该类通过mapper.xml中配置的唯一<cache/>标签生成的Cache类存放每个方法执行的结果

MyBatis 的工作原理：读取 MyBatis 配置文件、加载映射文件、构造会话工厂、创建会话对象、Executor 执行器、输入参数映射、输出结果映射。mybatis原理具体介绍如下：1、读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。2、加载映射文件：映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。3、构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。4、创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。5、Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。6、MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。7、输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。8、输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

啊啊啊

surroundback和surround区别如下：1、surroundback是音箱，surround是指声。2、surroundback需要接音箱，surround是声音可以公放。3、surroundback的词义比surround复杂。

期待。。

Dim myMenuBar Dim newMenu Dim ctrl1 Dim s Dim flag As String "初始化菜单 Set myMenuBar = CommandBars.ActiveMenuBar Set newMenu = myMenuBar.Controls.Add(Type:=msoControlPopup, _ Temporary:=True) newMenu.Caption = "电子印章" Set ctrl1 = newMenu.Controls.Add(Type:=msoControlButton, ID:=1) ctrl1.Caption = "添加电子印章" ctrl1.Style = msoButtonCaption ctrl1.OnAction = "AddSeal" Set ctrl1 = newMenu.Controls.Add(Type:=msoControlButton, ID:=1) ctrl1.Caption = "验证电子印章" ctrl1.Style = msoButtonCaption ctrl1.OnAction = "CheckSeal" ctrl1.Style = msoButtonCaption Set ctrl1 = newMenu.Controls.Add(Type:=msoControlButton, ID:=1) ctrl1.Caption = "关于" ctrl1.OnAction = "About" ctrl1.Style = msoButtonCaption

public XtraForm1(){InitializeComponent();}private BarDockControl barDockControlTop;private BarDockControl barDockControlBottom;private BarDockControl barDockControlLeft;private BarDockControl barDockControlRight;private BarManager barManager;private Bar statusBar;private Bar toolsBar;private Bar menuBar;private void simpleButton1_Click(object sender, EventArgs e){barManager = new BarManager();statusBar = new Bar();toolsBar = new Bar();menuBar = new Bar();this.barDockControlTop = new DevExpress.XtraBars.BarDockControl();this.barDockControlBottom = new DevExpress.XtraBars.BarDockControl();this.barDockControlLeft = new DevExpress.XtraBars.BarDockControl();this.barDockControlRight = new DevExpress.XtraBars.BarDockControl();this.barManager.Bars.AddRange(new Bar[] {this.statusBar,this.menuBar,this.toolsBar});this.barManager.DockControls.Add(this.barDockControlTop);this.barManager.DockControls.Add(this.barDockControlBottom);this.barManager.DockControls.Add(this.barDockControlLeft);this.barManager.DockControls.Add(this.barDockControlRight);this.barManager.Form = this;this.barManager.MainMenu = this.menuBar;this.barManager.MaxItemId=0;this.barManager.StatusBar = statusBar;//// toolsBar//this.toolsBar.BarName = "Tools";this.toolsBar.DockCol = 0;this.toolsBar.DockStyle = DevExpress.XtraBars.BarDockStyle.Top;this.toolsBar.Text = "工具栏";//// menuBar//this.menuBar.BarName = "MainMenu";this.menuBar.DockCol = 0;this.menuBar.DockStyle = DevExpress.XtraBars.BarDockStyle.Top;this.menuBar.OptionsBar.MultiLine = true;this.menuBar.OptionsBar.UseWholeRow = true;this.menuBar.Text = "菜单栏";//// statusBar//this.statusBar.BarName = "Statusbar";this.statusBar.CanDockStyle = DevExpress.XtraBars.BarCanDockStyle.Bottom;this.statusBar.DockCol = 0;this.statusBar.DockStyle = DevExpress.XtraBars.BarDockStyle.Bottom;this.statusBar.OptionsBar.AllowQuickCustomization = false;this.statusBar.OptionsBar.DrawDragBorder = false;this.statusBar.OptionsBar.UseWholeRow = true;this.statusBar.Text = "状态栏";}

你的代码是正确的,但是如果你要显示图标,你需要把所有ctrl1.style = msoButtonCaption 这一句改为 ctrl1.Style = msoButtonIconAndCaption,这样就能够一起显示图标和文字了,我试过是可以的,希望能帮到你

scrollbars=yes,即可。

系统变量MENUBAR有两个值，0和1为0时不显示CAD菜单栏为1时显示菜单栏

可以关闭工程试试,并删除*.ncb文件,重新编译

新版本应该没有这个选项的。。。老版本的消息提示是自己提供的。。。但是新版本都是纳入到系统的通知中心里去了。。。而且。。。系统栏里的图标有很多功能啊。。。现在的 qq 面板基本已经没啥作用了。。。顶多就是看看都谁在。。。然后跟谁聊天就是了。。。你要是觉得系统栏图标碍眼。。。就把他移到最右侧。。。就是你现在这个设置。。。一般也看不到它吧。。。

MFC标准单文档程序的菜单，不需要“重新加载”，你只需要获取框架窗口（因为菜单是从属于框架的）指针，或者在CMainFrame类中直接：//删除子菜单:GetMenu()->DeleteMenu(1,MF_BYPOSITION);//删除菜单项：GetMenu()->GetSubMenu(0)->DeleteMenu(2,MF_BYPOSITION);就可以实现删除了。

这个是成员函数，返回的是一个对象，谢谢。

menubar=new JMenuBar();是给前面“JMenuBar menubar;/*菜单条*/”声明的菜单条，创建一个对象。目的是为了存放这个“menu=new JMenu("文件");”菜单。 ，

谁知道你是继承的什么，还是自己的方法。问题太不清楚了

也不知道你说的是不是Swing/awt。如果是swing之类的话，还是使用addActionListener监听事件。比如：public class myClass{JMenuBar menuBar = new JMenuBar();JMenu jmexit = new JMenu("退出系统");JMenuItem jmclose= new JMenuItem("确定退出系统");public myClass(){ jmexit.add(jmclose); menuBar.add(jmexit); setJMenuBar(menuBar); jmclose.addActionListener(new myClass_jbclose_actionAdapter(this)); }

menuItem.addActionListener(this); 下面是一个参考例子 import javax.swing.*; import java.awt.event.*; public class MenuListener extends JFrame implements ActionListener { private JMenu menu; private JMenuItem menuItem; private JMenuBar menuBar; public MenuListener() { menu=new JMenu("编辑"); menuItem=new JMenuItem("复制"); menuItem.addActionListener(this); //注册监听器menuBar=new JMenuBar(); menu.add(menuItem); menuBar.add(menu); setJMenuBar(menuBar); setSize(200,100); //menuItem.addActionListener(this); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置关闭方式} public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(null,"编辑"); } public static void main(String[] args) { JFrame.setDefaultLookAndFeelDecorated(true); //设置窗口使用最新的样式MenuListener m=new MenuListener(); m.setVisible(true); } }

输入menubar,修改变量值。如图“0”隐藏菜单栏；“1”显示菜单栏。

为什么不能成功运行？

JMenuBar1.setBackground(Color.blue);

setJMenuBar()setJMenuBarpublic void setJMenuBar(JMenuBar menubar)设置此窗体的菜单栏。 参数：menubar - 放置于该窗体中的菜单栏另请参见：getJMenuBar()------------------------------------------------------------------------------------------------------------------------setMenuBarpublic void setMenuBar(MenuBar mb)将此 frame 的菜单栏设置为指定的菜单栏。 参数：mb - 正被设置的菜单栏。如果此参数为 null，则移除此 frame 上所有现有的菜单栏。另请参见：getMenuBar()

MenuBar 重量级组件JMenuBar 轻量级组件 支持 L&F。

窗体的菜单项

wdawe

bape北京三里屯，其他在哪里基本都有

刹车辅助系统下线了。BAS是英文BrakeAssistSystem的缩写，中文是刹车辅助系统，功能是为了弥补急刹车时ABS防抱死系统启动造成的刹车距离延长。

抱歉，是坏的产物（结果）bad spawn, sorryspawn 英 [spɔ:n] 美 [spɔn] vt. （鱼、蛙等）大量产（卵） ; 引起，酿成; vt. 大量生产; n. （鱼、蛙等的） 子，卵; （裂殖菌类植物的） 丝，菌; 产物，结果; [例句]Tyndall"s inspired work spawned a whole new branch of science由廷德尔富有创见的著作发展出了一个崭新的科学分支。[其他] 第三人称单数：spawns 复数：spawns 现在分词：spawning 过去式：spawned 过去分词：spawned

commit或者rollback。两者选其一，而且必选其一，才能够确保一个事务被可靠的，安全的终止。commit意味着对事务中的操作确定，rollback意味着对事务中的操作否定。

rollback意思是返回原来的状态(即没更新前的可用稳定状态)。也允许用户在系统启动期间或在本身不支持USB设备的操作系统（如Microsoft DOS）的应用程序或实用程序中使用连接到USB端口上的USB键盘、鼠标或集线器。还有一个重要的功能可以让USB键盘也可以按DEL直接进入到BIOS设置。如果不开启的话USB接口的键盘就无法运行，进入到BIOS设置的界面了。传动比选择：起动机与发动机之间的最佳传动比应能保证发动机可靠起动，同时能使起动机达到最大功率。在实际选择中，由于受飞轮齿圈和驱动齿轮的结构限制，传动比往往稍小于最佳值。这种选择结果，使起动机在工作时并没有达到最大功率。但起动机的转矩增大，对起动是有利的。起动机与发动机的传动比一般在如下范围内选择。汽油发动机为13～17，柴油发动机为8～10。

Oracle enforces statement-level read consistency. This ensures that the data returned by a single query is consistent with respect to the time when the query began. Therefore, a query never sees the data changes made by transactions that commit during the course of execution of the query. Usually, a long running query has error ORA-1555 if the data accessed by the query is updated and committed by another user or session after the query has been started. The most common reasons for error ORA-1555 (snapshot too old) are: A long running query due to a poorly qualified data access A high processing time between fetches of the same query Incorrect rollback segment setup A long run query can cause some activities in the ABAP program loop to take too long, even if the SQL statement is correct. For example: SELECT ... Fetch (a long running activity) ENDSELECT Before you try to change the number or size of the rollback segments, check if the problem is caused by expensive queries, such as inefficient application design, wrong index design, or insufficient cost-based optimizer statistics. You can adjust the rollback segment setup by adding more rollback segments or making them larger. you can please have a look at SAP notes 60233 to increase rollback segment size/number. suggest: increase rollback segment number to 40 frist. if you still meet ORA-01555 increase the size.

运行 msconfig → 引导 → 把 windows rollback 删了

这是windows 回滚。撤销安装。

secure是安全rollback是回退，降级的意思preventation是防止这个词组一般是在电脑的bios里的一个设置项，用来防止bios降级的。如果bios升级之后想要降级，需要把这个项置为0或者off

什么意思？只有当@@Error<0时才commit，既然没有错误就提交了，也就不会再回滚了。if(@@Error<0) Commit;else RollBack;

这个完全看你自己的需求。如果是你不需要再存储过程中进行提交，而是由调用程序负责提交或者回滚，那么不需要再存储过程中commit或者rollback如果你不想由调用程序负责提交或者回滚，那么应该在存储过程中进行commit或rollback

会执行。一般回滚操作都是写在异常处理，或是sql的最后。如果你的sql中出现错误，代码会立即跳转到错误处理代码上执行，比如回滚，但紧接在错误行之后的代码不会执行的。

答案是 对的