spring

spring forth蓬勃生长；放出了；涌流出来例句These passages of happy couples are a profound appeal to life and nature, and make a caress and light spring forth from everything.这一对对情侣的活动是对人生和自然发出的一种强烈的呼声，使天地万物都放出了爱和光。We then went to a Fountain attached to a Jewish Ghetto and asked for the waters in the Belly of Church to be purified and spring forth.随后我们来到一个附属于犹太区的喷泉，并求神洁净教会肚腹中的泉水并能涌流出来。And there would be a new beginning. a new tree of life would spring forth from this pyramid, and its matrix, joining with the other11 pyramids of creation.而就会有新的开端。一新生命树从这金字塔和它的矩阵里蓬勃生长，与其它11个创造的金字塔相连接。

spring forward春天降临；拨快一个小时；向前进例句1.His friends spring forward to help him.他的朋友们跳起来去想要去帮他。2.Spring forward to this annual thought, emotion will came over in life, or light or dark to linger heart.思想着这一年一度的春色，人生的感慨便会油然而起，或淡或浓地萦回心头。3.But so many people like to "spring forward" that it might be hard for officials to end the tradition, even if they determined it"s wasteful.但很多人已经习惯了“钟表向前拨动”，这就对政府终结这一传统造成了困难，虽然他们都知道这是浪费。4.Stop slacking spring forward.停止松艏倒缆。5.When did my colds a forward spring remove?我的冰冷何时曾扼杀早来的春季？

源码的编译路径设置了没有?是否是设置了classes目录下?

request依赖于web应用，request就类似与你的servlet，多个用户访问一个servlet，当然是访问servlet的多个实例，prototype实际上是new出来的，你想想，你的bean里new了一个对象，为什么要让spring给你销毁。prototype没有什么好不好的，只不过它能做singleton所不能做得（创建多个实例），在web项目之外也可以做request所不能做得事。prototype的销毁你不必关心，调用它的bean销毁了，它也就销毁了。request是web里所特有的。看来是java web做多了

首先会进入 UsernamePasswordAuthenticationFilter 并且设置权限为null和是否授权为false，然后进入 ProviderManager 查找支持 UsernamepasswordAuthenticationToken 的 provider 并且调用 provider.authenticate(authentication); 再然后就是 UserDetailsService 接口的实现类（也就是自己真正具体的业务了），这时候都检查过了后，就会回调 UsernamePasswordAuthenticationFilter 并且设置权限（具体业务所查出的权限）和设置授权为true（因为这时候确实所有关卡都检查过了）。 UsernamePasswordAuthenticationFilter 可以发现继承了 AbstractAuthenticationProcessingFilter ，那我们就来看下此类 1、继承了父类，父类是个过滤器，所以肯定先执行 AbstractAuthenticationProcessingFilter.doFilter() ，此方法首先判断当前的filter是否可以处理当前请求，不可以的话则交给下一个filter处理。 2、调用此抽象类的子类 UsernamePasswordAuthenticationFilter.attemptAuthentication(request, response) 方法做具体的操作。 3、最终认证成功后做一些成功后的 session 操作，比如将认证信息存到 session 等。 4、最终认证成功后的相关回调方法，主要将当前的认证信息放到 SecurityContextHolder 中并调用成功处理器做相应的操作。 1、父类的 authResult = attemptAuthentication(request, response); 触发了自类的方法。 2、此方法首先判断请求方式是不是POST提交，必须是POST 3、从请求中获取 username 和 password ，并做一些处理 4、封装 Authenticaiton 类的实现类 UsernamePasswordAuthenticationToken 5、调用 AuthenticationManager 的 authenticate 方法进行验证 1、怎么触发的？ 2、 ProviderManager.authenticate(Authentication authentication); **3、此方法遍历所有的Providers，然后依次执行验证方法看是否支持 UsernamepasswordAuthenticationToken** 4、若有一个能够支持当前token，则直接交由此 provider 处理并break。 5、若没一个 provider 验证成功，则交由父类来尝试处理 1、怎么触发的？ 2、 DaoAuthenticationProvider 3、继承了 AbstractUserDetailsAuthenticationProvider 4、 AbstractUserDetailsAuthenticationProvider.authenticate() 首先调用了 user = this.retrieveUser(username, (UsernamePasswordAuthenticationToken)authentication); 5、调用我们自己的业务处理类 比如： 6、调用完 retrieveUser 方法继续回到抽象类的 authenticate 方法 7、首先做一些检查 8、调用 createSuccessAuthentication 方法进行授权成功 9、回到起点 进行session存储和成功后的处理器的调用等 只是简单说下类之间的调用顺序。 大功告成！ 只需要一个html，一段配置，一个Service自己的业务类即可。 疑问： 1、接口login在哪定义的？ 2、用户名 username 和密码 password 在哪接收的？ 3、没有控制器怎么进入我们的 MyUserDetailsService 的方法？ 解答： 1、 SpringSecurity 内置的，并且只能为 POST 2、名称不能变，必须是 username 和 password 3、自己看我上面的源码分析

在调用资源服务器的过程中，我们会将申请的token 作为header值进行传递，携带调用者的身份信息。但是资源服务器是如何通过token对调用者的身份进行判断的呢？ Security中有一个Filter实现了对token信息的转换，将token值转换成了调用者的用户信息。该filter就是 Oauth2AuthenticationProcessingFilter 一、查看源码 查看Oauth2AuthenticationProcessingFilter的doFilter方法 通过查看Oauth2AuthenticationProcessingFilter的dofilter方法，重点有两点 （1）将request中的token提取出来封装成Authentication对象 （2）将Authentication交给authenticationManager进行鉴权处理 下面我们重点看下这两处的处理。 二、token到Authentication对象转换实现 Authentication authentication = tokenExtractor .extract(request); tokenExtractor在Oauth2AuthencationProcessingFilter中的默认实现是BearerTokenExtractor，我们查看BearerTokenExtractor的extract()方法。 三、Authentication对象的鉴权 Authentication authResult = authenticationManager .authenticate(authentication); 此处的authenticationManager的实现类是Oauth2AuthenticationManager，而不是我们之前一直提到的ProvicerManager。我们看下Oauth2AuthenticationManager中的authenticate()方法。 RemoteTokenService 的 loadAuthentication() 方法 用户认证转换类 * 接口层注入的 OAuth2Authentication对象中的 principal属性即在该类的extractAuthentication() 方法中实现的。 * security默认使用的是 DefaultAccessTokenConverter类中的extractAuthentication()方法中使用。 * 通过继承UserAuthenticationConverter该类，实现其中的extractAuthentication()方法来满足我们自己构造 principal属性的需求。 * 在ResourceConfig类中，继续使用DefaultAccessTokenConverter,但是类中的UserAuthenticationConverter我们里换成我们自己的CustomUserAuthenticationConverter实现类。 * * 我们构造的principal属性是map类，里面包含phone和userId两个字段。

但是这样请求的话，请求的时候需要套多一层 参考文章

开源是3个框架共有的优点Struts2框架（MVC框架）的优点如下：1） 实现了MVC模式，层次结构清晰，使程序员只需关注业务逻辑的实现；2） 丰富的标签库，大大提高了开发的效率；3） Struts2提供丰富的拦截器实现3） 通过配置文件，就可以掌握整个系统各个部分之间的关系；4） 异常处理机制，只需在配置文件中配置异常的映射，即可对异常做相应的处理；Spring框架的优点如下：1） 无入侵性（在业务逻辑代码中感觉不到Spring框架的存在）；2） 各个组件之间的耦合极为松散；3） 无需程序员自己实现singleton模式；4） 通过AOP，可以实现事务管理和日志管理；5） 整合其他的框架，如：struts框架和hibernate框架；Hibernate框架（ORM框架）的优点如下：1） 对象/关系数据库映射（ORM）， 使用时只需操纵对象，使开发更加面向对象化；2） 无入侵性；3） 简洁的HQL语句，减少了JDBC与SQL操作数据库的代码量；4） 移植性好；缺点如下：1） 对批量更新，删除的支持不好；

之前也写过一篇关于 Spring Validation 使用的文章，不过自我感觉还是浮于表面，本次打算彻底搞懂 Spring Validation 。 本文会详细介绍 Spring Validation 各种场景下的最佳实践及其实现原理，死磕到底！ Java API 规范 ( JSR303 ) 定义了 Bean 校验的标准 validation-api ，但没有提供实现。 hibernate validation 是对这个规范的实现，并增加了校验注解如 @Email 、 @Length 等。 Spring Validation 是对 hibernate validation 的二次封装，用于支持 spring mvc 参数自动校验。接下来，我们以 spring-boot 项目为例，介绍 Spring Validation 的使用。 如果 spring-boot 版本小于 2.3.x ， spring-boot-starter-web 会自动传入 hibernate-validator 依赖。如果 spring-boot 版本大于 2.3.x ，则需要手动引入依赖： 对于 web 服务来说，为防止非法参数对业务造成影响，在 Controller 层一定要做参数校验的！大部分情况下，请求参数分为如下两种形式： 下面我们简单介绍下 requestBody 和 requestParam/PathVariable 的参数校验实战！ POST 、 PUT 请求一般会使用 requestBody 传递参数，这种情况下，后端使用** DTO 对象 进行接收。 只要给 DTO 对象加上 @Validated 注解就能实现自动参数校验**。比如，有一个保存 User 的接口，要求 userName 长度是 2-10 ， account 和 password 字段长度是 6-20 。如果校验失败，会抛出 MethodArgumentNotValidException 异常， Spring 默认会将其转为 400（Bad Request） 请求。 DTO 表示数据传输对象（Data Transfer Object），用于服务器和客户端之间交互传输使用的 。在 spring-web 项目中可以表示用于接收请求参数的 Bean 对象。 这种情况下， 使用 @Valid 和 @Validated 都可以 。 前面说过，如果校验失败，会抛出 MethodArgumentNotValidException 或者 ConstraintViolationException 异常。在实际项目开发中，通常会用 统一异常处理 来返回一个更友好的提示。比如我们系统要求无论发送什么异常， http 的状态码必须返回 200 ，由业务码去区分系统的异常情况。 在实际项目中，可能多个方法需要使用同一个 DTO 类来接收参数，而不同方法的校验规则很可能是不一样的。这个时候，简单地在 DTO 类的字段上加约束注解无法解决这个问题。因此， spring-validation 支持了 分组校验 的功能，专门用来解决这类问题。还是上面的例子，比如保存 User 的时候， UserId 是可空的，但是更新 User 的时候， UserId 的值必须 >=10000000000000000L ；其它字段的校验规则在两种情况下一样。这个时候使用 分组校验 的代码示例如下： 前面的示例中， DTO 类里面的字段都是 基本数据类型 和 String 类型。但是实际场景中，有可能某个字段也是一个对象，这种情况先，可以使用 嵌套校验 。 比如，上面保存 User 信息的时候同时还带有 Job 信息。需要注意的是， 此时 DTO 类的对应字段必须标记 @Valid 注解 。 嵌套校验可以结合分组校验一起使用。还有就是 嵌套集合校验 会对集合里面的每一项都进行校验，例如 List 字段会对这个 list 里面的每一个 Job 对象都进行校验。 如果请求体直接传递了 json 数组给后台，并希望对数组中的每一项都进行参数校验。此时，如果我们直接使用 java.util.Collection 下的 list 或者 set 来接收数据，参数校验并不会生效！我们可以使用自定义 list 集合来接收参数： @Delegate 注解受 lombok 版本限制， 1.18.6 以上版本可支持。如果校验不通过，会抛出 NotReadablePropertyException ，同样可以使用统一异常进行处理。 比如，我们需要一次性保存多个 User 对象， Controller 层的方法可以这么写： 业务需求总是比框架提供的这些简单校验要复杂的多，我们可以自定义校验来满足我们的需求。自定义 spring validation 非常简单，假设我们自定义 加密id （由数字或者 a-f 的字母组成， 32-256 长度）校验，主要分为两步： 这样我们就可以使用 @EncryptId 进行参数校验了！ 上面的示例都是基于 注解 来实现自动校验的，在某些情况下，我们可能希望以 编程方式 调用验证。这个时候可以注入 javax.validation.Validator 对象，然后再调用其 api 。 Spring Validation 默认会校验完所有字段，然后才抛出异常。可以通过一些简单的配置，开启 Fali Fast 模式，一旦校验失败就立即返回。 在 spring-mvc 中， RequestResponseBodyMethodProcessor 是用于解析 @RequestBody 标注的参数以及处理 @ResponseBody 标注方法的返回值的。显然，执行参数校验的逻辑肯定就在解析参数的方法 resolveArgument() 中： 可以看到， resolveArgument() 调用了 validateIfApplicable() 进行参数校验。 看到这里，大家应该能明白为什么这种场景下 @Validated 、 @Valid 两个注解可以混用。我们接下来继续看 WebDataBinder.validate() 实现。 最终发现底层最终还是调用了 Hibernate Validator 进行真正的校验处理。 接着看一下 MethodValidationInterceptor ： 实际上，不管是 requestBody参数校验 还是 方法级别的校验 ，最终都是调用 Hibernate Validator 执行校验， Spring Validation 只是做了一层封装 。 本人花费2个月时间，整理了一套JAVA开发技术资料，内容涵盖java基础，分布式、微服务等主流技术资料，包含大厂面经，学习笔记、源码讲义、项目实战、讲解视频。 java面试资料 私信回复【2022面试资料】 领取更多学习资料

Hibernate Validator 是 Bean Validation 的参考实现 。Hibernate Validator 提供了 JSR 303 规范中所有内置 constraint 的实现，除此之外还有一些附加的 constraint 在日常开发中，Hibernate Validator经常用来验证bean的字段，基于注解，方便快捷高效。 在SpringBoot中可以使用@Validated，注解Hibernate Validator加强版，也可以使用@Valid原来Bean Validation java版本 Bean Validation 中内置的 constraint <colgroup style="box-sizing: border-box;"><col style="box-sizing: border-box;"><col style="box-sizing: border-box;"></colgroup> Hibernate Validator 附加的 constraint message支持表达式和EL表达式 ，比如message = "姓名长度限制为{min}到{max} ${1+2}") 想把错误描述统一写到properties的话，在classpath下面新建 ValidationMessages_zh_CN.properties文件(注意value需要转换为unicode编码)，然后用{}格式的占位符 hibernate补充的注解中，最后3个不常用，可忽略。 主要区分下@NotNull @NotEmpty @NotBlank 3个注解的区别： 如果同一个参数，需要在不同场景下应用不同的校验规则，就需要用到分组校验了。比如：新注册用户还没起名字，我们允许name字段为空，但是在更新时候不允许将名字更新为空字符。 分组校验有三个步骤： 自定义的Update分组接口继承了Default接口。校验注解(如： @NotBlank)和@validated默认其他注解都属于Default.class分组，这一点在 javax.validation.groups.Default注释中有说明 在编写Update分组接口时，如果继承了Default，下面两个写法就是等效的： @Validated({Update.class}),@Validated({Update.class,Default.class}) 如果Update不继承Default，@Validated({Update.class})就只会校验属于Update.class分组的参数字段 如果 UserVO 类中增加一个 OrderVO 类的属性，而 OrderVO 中的属性也需要校验，就用到递归校验了，只要在相应属性上增加@Valid注解即可实现（对于集合同样适用） validation 为我们提供了这么多特性，几乎可以满足日常开发中绝大多数参数校验场景了。但是，一个好的框架一定是方便扩展的。有了扩展能力，就能应对更多复杂的业务场景，毕竟在开发过程中，唯一不变的就是变化本身。 Validation允许用户自定义校验 实现很简单，分两步： 注意:message用于显示错误信息这个字段是必须的，groups和payload也是必须的 @Constraint(validatedBy = { HandsomeBoyValidator.class})用来指定处理这个注解逻辑的类 注意这里验证逻辑我抽出来单独写了一个工具类，ValidatorUtil 我自定义了补充了很多验证器，包括日期验证，枚举验证，手机号验证，金额验证 自定义校验注解使用起来和内置注解无异，在需要的字段上添加相应注解即可 使用 Validation API 进行参数效验步骤整个过程如下图所示，用户访问接口，然后进行参数效验 ，如果效验通过，则进入业务逻辑，否则抛出异常，交由全局异常处理器进行处理 全局异常出来请参考我这篇文章SpringBoot优雅的全局异常处理

歌曲名:The Angel歌手:Bruce Springsteen专辑:Greetings From Asbury Park, N.J.Lord, oh my LordWhy this place, magic placeThe mist is everywhereThe light is in the airI hear in the skyThe whisper of the timeI need an answerA reason to my prayerbyThe Angel以下段送于my love zyjYou"re the angelWhite as the winterYou"re the angelForeverYou"re the angelWhite as the winterYou"re the angelForeverSo far awayThrough the lightThrough the skyTil the end of timeYou"re the angelWhite as the winterYou"re the angelWhite as the winterWhite as the wings of lifehttp://music.baidu.com/song/9726967

首先我使用的是注解的方式。创建properties配置文件Key=value的形式在spring的配置文件中进行导入代码如下：<util:properties id="test" location="classpath:test.properties"/>提示：路径问题自己把握3.在你需要使用的类中这样：private @Value("#{test["isOpen"]}") String isOpen;记得写getset方法isOpen这个在test.properties中是这样的：isOpen=true如果有任何问题，可追加。望采纳

一般来说。我们会将一些配置的信息放在。properties文件中。然后使用${}将配置文件中的信息读取至spring的配置文件。那么我们如何在spring读取properties文件呢。1.首先。我们要先在spring配置文件中。定义一个专门读取properties文件的类.例： <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> <!--要是有多个配置文件，只需在这里继续添加即可 --> </list> </property> </bean>这里为什么用locations（还有一个location)是因为。一般来说。我们的项目里面。配置文件可能存在多个。就算是只有一个。那将来新添加的话。只需在下面再加一个value标签即可。而不必再重新改动太多。（当然。性能上是否有影响，这个以当前这种服务器的配置来说。是基科可以忽略不计的）。然后我们就可以在jdbc.properties文件中填写具体的配置信息了。 <!-- 配置C3P0数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.username}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> </bean>jdbc.properties文件写的信息。jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=rootjdbc.password=root附加一个列子：　　<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>file:/data/pc-config/passport.properties</value> <value>classpath:memcached.properties</value> </list> </property> </bean>　　classpath：是指的当前类文件的目录下。　　file：在window下是指的当前分区（比如你的项目是放在d盘，则是在d：/data/pc-config/passport.properties）　　在linux下，则是当前路径下的文件/data/pc-config/passport.properties转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦

　　一般来说。我们会将一些配置的信息放在。properties文件中。然后使用${}将配置文件中的信息读取至spring的配置文件。那么我们如何在spring读取properties文件呢。1.首先。我们要先在spring配置文件中。定义一个专门读取properties文件的类.例： <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> <!--要是有多个配置文件，只需在这里继续添加即可 --> </list> </property> </bean>这里为什么用locations（还有一个location)是因为。一般来说。我们的项目里面。配置文件可能存在多个。就算是只有一个。那将来新添加的话。只需在下面再加一个value标签即可。而不必再重新改动太多。（当然。性能上是否有影响，这个以当前这种服务器的配置来说。是基科可以忽略不计的）。然后我们就可以在jdbc.properties文件中填写具体的配置信息了。 <!-- 配置C3P0数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.username}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> </bean>jdbc.properties文件写的信息。jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=rootjdbc.password=root附加一个列子：　　<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>file:/data/pc-config/passport.properties</value> <value>classpath:memcached.properties</value> </list> </property> </bean>　　classpath：是指的当前类文件的目录下。　　file：在window下是指的当前分区（比如你的项目是放在d盘，则是在d：/data/pc-config/passport.properties）　　在linux下，则是当前路径下的文件/data/pc-config/passport.properties转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦

如何在spring中读取properties配置文件里面的信息<!-- 正文开始 -->一般来说。我们会将一些配置的信息放在。properties文件中。然后使用${}将配置文件中的信息读取至spring的配置文件。那么我们如何在spring读取properties文件呢。1.首先。我们要先在spring配置文件中。定义一个专门读取properties文件的类.例： <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> <!--要是有多个配置文件，只需在这里继续添加即可 --> </list> </property> </bean>这里为什么用locations（还有一个location)是因为。一般来说。我们的项目里面。配置文件可能存在多个。就算是只有一个。那将来新添加的话。只需在下面再加一个value标签即可。而不必再重新改动太多。（当然。性能上是否有影响，这个以当前这种服务器的配置来说。是基科可以忽略不计的）。然后我们就可以在jdbc.properties文件中填写具体的配置信息了。 <!-- 配置C3P0数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.username}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> </bean>jdbc.properties文件写的信息。jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=rootjdbc.password=root附加一个列子： <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>file:/data/pc-config/passport.properties</value> <value>classpath:memcached.properties</value> </list> </property> </bean>classpath：是指的当前类文件的目录下。file：在window下是指的当前分区（比如你的项目是放在d盘，则是在d：/data/pc-config/passport.properties） 在linux下，则是当前路径下的文件/data/pc-config/passport.properties

蓝白相间的颜色。特　　性：（网上查到） a:窄边方头低断面设计.甜点区增大. b:加长握把,增加球拍控制范围. c:前套专利Vibration Cap避震,减少25%震动 d:高级坚实的头框前段WAVE波浪系统，它提供球拍线更好的传送力，增加其POWER及扭力稳性. e:方形拍头 与传统球拍相比，均等化方形拍头能提供额外多32%的有效击球面积(击球甜区）即使是偏离球拍线床中心区的连续式扣杀也能保持相应的精确和速度。 f:前半段框采用拱形线槽　传统球拍的承线系统中，拍线被直接支撑在尖锐的线孔胶粒边缘上，拉线后拍线与胶粒的两个接触点会产生应力集中现象，导致拍线疲劳，张力严重下降。新的波浪形结构系统将拍线支撑在圆拱形的线槽上，两个接触点被连接为一段接触弧面，不但有效消除应力，而且形成的紧密接触弧面大大增强了拍线与拍框的整体效应，从而增强了拍线与拍框的整体效应，从而增强球拍的整体稳定性和力量性能。

HEAV"N from all creatures hides the book of Fate,AR but the page prescrib"d, their present state,From brutes what men, from men what spirits know,Or who could suffer Being here below?The lamb thy riot dooms to bleed to-day,Had he thy Reason, would he skip and play?Pleas"d to the last, he crops the flow"ry food,And licks the hand just rais"d to shed his blood.Oh blindness to the future! kindly giv"n,That each may fill the circle mark"d by Heav"n:Who sees with equal eye, as God of all,A hero perish, or a sparrow fall,Atoms or systems into ruin hurl"d,And now a bubble burst, and now a world.Hope humbly then; with trembling pinions soar;Wait the great teacher, Death; and God adore!What future bliss, he gives not thee to know,But gives that Hope to be thy blessing now,Hope springs eternal in the human breast;Man never is, but always to be blest:The soul uneasy, and confin"d at home,Rests, and expatiates, in a life to come.Lo! the poor Indian, whose untutor"d mindSees God in clouds, or hears him in the wind;His soul, proud Science never taught to strayFar as the solar walk, or milky way;Yet simple Nature to his Hope has giv"n,Behind the cloud-topt hill, an humbler heav"n;Some safer world in depth of woods embrac"d,Some happier island in the watry waste,Where slaves once more their native land behold,No fiends torment, no Christians thirst for gold.To be, contents his natural desire,He asks no Angel"s wing, no Seraph"s fire;But thinks, admit来自所有生物的HEAV"N隐藏了命运书，AR，但页面规定，他们目前的状态，从野蛮人那些男人，男人的灵魂知道什么，或谁可能受苦在这里？羔羊你的暴乱今天会流血，如果他是你的理由，他会跳过并玩吗？最后，他开始播种流动的食物，然后舔手抓住他的血液。哦对未来失明！亲切的，每一个都可以填满Heav"n标记的圆圈：谁是平等的眼睛，作为所有人的上帝，英雄灭亡，或麻雀摔倒，原子或系统陷入毁灭，而现在泡沫破裂，现在是一个世界。希望谦卑地;颤抖的小齿翱翔;等待伟大的老师，死亡;而且上帝崇拜！未来的幸福，他不让你知道，但是，希望现在成为你的祝福，希望在人类的乳房中永生;男人永远不会，但总是要冷静：灵魂不安，并在家里，在未来的生活中休息和阐述。罗！可怜的印度人，他的无意识的头脑在云中看见上帝，或在风中听见他;他的灵魂，自豪的科学从未教会流浪太阳散步，或银河系;然而，他希望的简单自然已经存在了，在云层山的后面，一个更加谦逊的人;一些更安全的森林深处的世界，在浪费的一些更幸福的岛屿，奴隶们再一次看到自己的土地，没有恶魔折磨，没有基督徒渴望金子。满足他的自然欲望，他没有天使的翅膀，没有塞拉弗的火;但是，思考，承认

在使用Spring或Spring Boot时一些特殊的参数会被转义，或者因转义导致出现异常情况，本文汇总总结相关问题及解决方案，帮助大家快速定位和解决问题。 问题一：参数特殊符号被后端转义 WEB开发时，前端通过get/post方法传递参数的时，如果实参附带特殊符号，后端接收到的值中特殊符号就会被转义。 例如请求： http://localhost:10001/demo/index?name= 张三(1) 后端接收到的name值中“(”和“)”被转义。 针对此问题有以下解决方案： 1、检查web.xml里是否配置了过滤特殊字符的filter，若不需要可以关掉此filter。 2、java中可以使用org.apache.commons.lang包中的public static String unescapeHtml(String str)方法来进行解码。实践中尝试了很多方法没有解决，最后使用了该方法，将接收到的包含特殊字符的字符串通过该方法进行解码。 3、在Controller接收的参数前加上@RequestBody注解，示例如下： @PostMapping(value = "/add") @ResponseBody public String addMessage(@RequestBody ParamVo params) { } 通常情况下，基于RESTful的API经常使用@RequestBody来自动绑定body中的请求参数到实体类对象。使用@RequestBody能解决大多数情况的问题，但某些特殊字符依旧无法正常解决，还需要通过方案二进行补充解决。 使用该中方案进行数据交互时，前度对应的请求需要 声明dataType和contentType，传递的参数并用JSON.stringify()转为json字符串。 $.ajax({ url: CONTEXTPATH + "/add", type: "POST", dataType: "JSON", contentType : "application/json", data: JSON.stringify(Data), success: function (data) { 　　} }) 问题二：/被转义成%2F导致400错误 前端GET请求url中带有路径参数，参数中有/特殊字符，前端已经转义成了%2F，后端springboot并没有收到这个请求，直接返回了400的错误。 原因：据说是tomcat默认是不支持转义的，需要手动设置一下转化，搜索tomcat的设置可以找到，但在springboot中内置的tomcat，在yml中找不到相关的配置。 解决方案：修改启动类，添加系统参数并重写WebMvcConfigurerAdapter的configurePathMatch方法。 @SpringBootApplication public class Application extends WebMvcConfigurerAdapter { public static void main(String[] args) throws Exception { System.setProperty("org.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH", "true"); SpringApplication.run(Application.class, args); } @Override public void configurePathMatch(PathMatchConfigurer configurer) { UrlPathHelper urlPathHelper = new UrlPathHelper(); urlPathHelper.setUrlDecode(false); configurer.setUrlPathHelper(urlPathHelper); } } 其中实现WebMvcConfigurerAdapter接口新版本中改为实现WebMvcConfigurer接口。重写的方法名称是一样的。该部分也可以单独在WebMvc的配置类中实现，而不是放在启动类。 当然，设置tomcat的参数是需要写在main方法当中进行设置的。 问题三：整合jackson的转义 Spring Boot默认配置json转换工具就是Jackson, 如果你此时使用的正是Jackson框架，那么可在配置文件中进行是否转义的配置，配置项如下： spring.jackson.date-format=yyyy-MM-dd HH:mm:ss spring.jackson.serialization.indent_output=true spring.jackson.serialization.fail_on_empty_beans=false spring.jackson.defaultPropertyInclusion=NON_EMPTY spring.jackson.deserialization.fail_on_unknown_properties=false spring.jackson.parser.allow_unquoted_control_chars=true spring.jackson.parser.allow_single_quotes=true 其中重点关注allow_unquoted_control_chars项的配置。 当然，相应的配置如果是在配置类中实现的自定义ObjectMapper，可以在自定义时进行设置： @Configuration public class JacksonConfig { } 在类中做过修改中, 配置文件中的配置将不再起作用。 问题四：接收JSON时发生转义字符绑定对象失败 在做Spring boot 项目时发生json转义字符绑定对象失败，原因是json里面有些字段包括空格，反斜杠等，如果框架没有对这些json进行转化时，就会报类似如下错误 org.codehaus.jackson.JsonParseException: Illegal unquoted character ((CTRL-CHAR, code 9)): has to be escaped using backslash to be included in string value at [Source: java.io.StringReader@10cfc2e3 ; line: 1, column: 2461] 解决办法： 1、pom.xml文件增加fastjson依赖。 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.15</version> </dependency> 如果项目中已经引入则无需新增该依赖。 2、增加配置类 @SpringBootApplication public class JsonController extends WebMvcConfigurerAdapter { @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { super.configureMessageConverters(converters); FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); FastJsonConfig fastJsonConfig = new FastJsonConfig(); fastJsonConfig.setSerializerFeatures( SerializerFeature.PrettyFormat ); fastConverter.setFastJsonConfig(fastJsonConfig); converters.add(fastConverter); } } 这里的配置方法同问题二中的一样，新版本Spring Boot 通过WebMvcConfigurer接口来完成。

spring moon春天的月亮双语对照例句:1.All the restaurants in the peninsula are fully booked for new year"s eve, save for a few spots at spring moon. 除了嘉麟楼（spring moon）还有少数空位之外，半岛酒店（the peninsula）的所有餐厅都已订满。

很高兴告诉你！接收后就是proof，即校稿，主要都是下面这些内容 这表示你的文章已经录用后，在发给你proofs之前，要先填一些东西，第一个是order open access，这个的意思是如果你订了，你要付给出版社，而你的文章别人可以随便下载，不用付，意思就是你帮他们付了，所以不要订这个。另一个是order paper offprints ，就是你是不是要订纸质的论文，也要加，建议不要。第三是是否要把图片以彩色出版，这个也要加，所以也建议不要。第四个是转让版权，这个点同意就可以了。然后你会收到一个确认邮件，记住，上面的选项有些是订了就不能修改的。注意不要弄错了。在发给你proofs的时候，会有一个允许出版许可的文件，你可以打印下来 ，签好字，然后扫描一下，和corrections一起发给出版社就行了。为你解除疑惑是我的快乐！

很高兴告诉你！接收后就是proof，即校稿，主要都是下面这些内容这表示你的文章已经录用后，在发给你proofs之前，要先填一些东西，第一个是order open access，这个的意思是如果你订了，你要付给出版社，而你的文章别人可以随便下载，不用付，意思就是你帮他们付了，所以不要订这个。另一个是order paper offprints ，就是你是不是要订纸质的论文，也要加，建议不要。第三是是否要把图片以彩色出版，这个也要加，所以也建议不要。第四个是转让版权，这个点同意就可以了。然后你会收到一个确认邮件，记住，上面的选项有些是订了就不能修改的。注意不要弄错了。在发给你proofs的时候，会有一个允许出版许可的文件，你可以打印下来 ，签好字，然后扫描一下，和corrections一起发给出版社就行了。为你解除疑惑是我的快乐！

spring up 是“迅速出现，突然兴起”的意思。比如：Play areas for children are springing up all over the place. 儿童游乐场所如雨后春笋般地在哲哲地方四处出现。go up 的意思就比较多了，有“被建造”的意思，有“被烧毁”的意思，还有“（价格、温度）上升，上涨”的意思。

你想问的是kidsgetluckymoneyonthespringfe翻译成中文是什么吧？孩子们在春天得到压岁钱。kidsgetluckymoneyonthespringfe翻译成中文：孩子们在春天得到压岁钱。英文是西日耳曼语的一种语言，最早是在中世纪早期的英格兰使用的，该语言最终成为21世纪国际话语的主要语言。

GRAND SEIKO是普通机械。SPRING DRIVE是结合了电磁技术，用于提高走时精度。当然SPRING DRIVE技术也用于其他系列。

定时任务的实现方式有多种，例如JDK自带的Timer+TimerTask方式，Spring 3.0以后的调度任务(Scheduled Task)，Quartz等。Timer+TimerTask是最基本的解决方案，但是比较远古了，这里不再讨论。Spring自带的Scheduled Task是一个轻量级的定时任务调度器，支持固定时间(支持cron表达式)和固定时间间隔调度任务，支持线程池管理。以上两种方式有一个共同的缺点，那就是应用服务器集群下会出现任务多次被调度执行的情况，因为集群的节点之间是不会共享任务信息的，每个节点上的任务都会按时执行。Quartz是一个功能完善的任务调度框架，特别牛叉的是它支持集群环境下的任务调度，当然代价也很大，需要将任务调度状态序列化到数据库。Quartz框架需要10多张表协同，配置繁多，令人望而却步...经过折中考虑，还是选择了Spring的Scheduled Task来实现定时任务。如下：1. Spring配置文件application-context.xml中添加task命名空间和描述。[html] view plain copy<beans xmlns="http://www.springframework.org/schema/beans" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd"> 2. 添加调度器和线程池声明。[html] view plain copy<task:executor id="taskExecutor" pool-size="10" /> <task:annotation-driven executor="taskExecutor" /> 3. 实现调度方法。基本结构如下：[html] view plain copypackage com.netease.yx.service; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; @Service public class ScheduledService { @Scheduled(cron = "0 0 5 * * *") public void build() { System.out.println("Scheduled Task"); } } @Scheduled注解支持秒级的cron表达式，上述声明表示每天5点执行build任务。前文已经提过，这种方式在单台应用服务器上运行没有问题，但是在集群环境下，会造成build任务在5点的时候运行多次，遗憾的是，Scheduled Task在框架层面没有相应的解决方案，只能靠程序员在应用级别进行控制。如何控制？1. 无非是一个任务互斥访问的问题，声明一把全局的“锁”作为互斥量，哪个应用服务器拿到这把“锁”，就有执行任务的权利，未拿到“锁”的应用服务器不进行任何任务相关的操作。2.这把“锁”最好还能在下次任务执行时间点前失效。在项目中我将这个互斥量放在了redis缓存里，1小时过期，这个过期时间是由任务调度的间隔时间决定的，只要小于两次任务执行时间差，大于集群间应用服务器的时间差即可。完整定时任务类如下：[html] view plain copypackage com.netease.yx.service; import javax.annotation.Resource; import org.apache.commons.lang3.time.DateUtils; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; import com.netease.yx.service.ICacheService; @Service public class ScheduledService { @Resource private ICacheService cache = null; private static String CACHE_LOCK = "cache_lock"; private static int EXPIRE_PERIOD = (int)DateUtils.MILLIS_PER_HOUR / 1000; @Scheduled(cron = "0 0 5 * * *") public void build() { if (cache.get(CACHE_LOCK) == null) { cache.set(CACHE_LOCK, true, EXPIRE_PERIOD); doJob(); } } }

你要理解quartz的调度机制，它需要在你启动系统时，和所有的bean一样加载到内存（这个时候就把需要初始化的东西全部初始完成，例如调度频率这里就该设置好）中并做好定时任务准备。所以频率一旦初始化了再去触发修改就难以完成了。当然你可以把这些初始化的参数放到数据库或者application.properties中方便维护和修改并不是修改代码

首先要配置我们的spring.xmlxmlns 多加下面的内容、然后xsi:schemaLocation多加下面的内容、最后是我们的task任务扫描注解[html] view plaincopy<task:annotation-driven/> 我的配置扫描位置是：[html] view plaincopy<context:annotation-config/> <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

首先要配置我们的spring.xml xmlns 多加下面的内容、 然后xsi:schemaLocation多加下面的内容、 最后是我们的task任务扫描注解 [html] view plaincopy 我的配置扫描位置是： [html] view plaincopy 扫描的是com.test这样的包下的内容、 下面需要

定时任务是定时启动，你其他方法也调用不了。就算有返回值，你也获取不了。你的代码思路不对。

首先要配置我们的spring.xml xmlns 多加下面的内容、 然后xsi:schemaLocation多加下面的内容、 最后是我们的task任务扫描注解 [html] view plaincopy 我的配置扫描位置是： [html] view plaincopy 扫描的是com.test这样的包下的内容、 下面需要

我们在开发时经常会遇到一些需要定时执行的小任务，使用了 springboot 的定时任务后变得更加简单快捷，下面举个例子： Java配置中开户对Scheduled的支持： Schedule定时器cron表达式： Cron表达式是一个字符串，字符串以5或6个空格隔开，分为6或7个域，每一个域代表一个含义，Cron有如下两种语法格式： 一个cron表达式由空格分隔6个或者7个占位符组成，每个占位符代表不同意义，分别为：秒、分钟、小时、日、月、周、年 * ：代表整个时间段。假如在Minutes域使用*, 即表示每分钟都会触发事件。 ? ：表示每月的某一天，或第周的某一天；只能用在DayofMonth和DayofWeek两个域，表示不指定值。当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用 ，如果使用 表示不管星期几都会触发，实际上并不是这样。 - ：表示范围，例如在Minutes域使用 5-20，表示从5分到20分钟每分钟触发一次 。 / ：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用“0/10”，表示每隔10分钟执行一次，“0”表示为从“0”分开始；如果是“5/20”，则意味着从5分开始，每20分钟触发一次，而25，45等分别触发一次，“5”表示从第5分钟开始执行.。 , ：表示列出枚举值值。例如：在Minutes域使用5,20，则意味着在第5分和第20分各触发一次。 L ：表示最后，只能出现在DayofWeek和DayofMonth域，用于每月，或每周，表示为每月的最后一天，或每个月的最后星期几。如果在DayofWeek域使用“5L”,意味着在最后的一个星期四触发；如“6L”表示“每月的最后一个星期五”。 W ：表示有效工作日(周一到周五)，只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用“5W”表示为“到本月5日最近的工作日”，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份。 LW ：这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。 # ：用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示每月的第二个星期三；如果是”6#3” 或 “FRI#3”，则表示“每月第三个星期五”。 最后推荐一个在线cron表达式生成器： http://cron.qqe2.com/

在spring boot中，支持多种定时执行模式（cron, fixRate, fixDelay），在Application或者其他Autoconfig上增加 @EnableScheduling注解开启。 然后在指定方法增加@Scheduled注解，如下： 需要注意的是，如果在多个函数上使用了@Scheduled，那么一定是一个执行完毕，才能排下一个。这往往不是我们想要的效果。此时需要在Scheduling配置类为schedule返回一个预定的线程池，如下： 完成之后，多个@Scheduled可以并发执行了，最高并发度是3，但是同一个@Schedule不会并发执行。 人生没有彩排，每天都是现场直播，开弓没有回头箭，努力在当下。

　　好像可以。　　Scheduled 可以作为一个触发源添加到一个方法中，例如，以下的方法将以一个固定延迟时间5秒钟调用一次执行，这个周期是以上一个调用任务的完成时间为基准，在上一个任务完成之后，5s后再次执行。

我也需要。坐等高手

项目中经常会用到定时任务。所以在这里总结一下在SSM框架中如何配置定时任务。 1、在spring的配置文件spring.xml（文件名可以任意）中增加如下配置 1）：spring配置文件加入头部加入 2）：spring配置文件加入定时任务注解配置 3）：spring配置文件加入定时任务扫描包 4）：spring配置文件加入配置定时任务的线程池。因为spring的定时任务默认是单线程，多个任务执行起来时间会有问题。 2、在package com.sc.api下新增定时任务相关类ScheduledApiTest 调用的两种方式： @Scheduled注解为定时任务，@Component 把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/> 1）：如果需要以固定速率执行，只要将注解中指定的属性名称改成fixedRate即可，以下方法将以一个固定速率1分钟来调用一次执行，这个周期是以上一个任务开始时间为基准，从上一任务开始执行后1分钟再次调用。 @Scheduled(fixedRate = 1000 60 30) //心跳更新。启动时执行一次，之后每隔1分钟执行一次 2）：如果你需要在特定的时间执行，就需要用到cron，cron表达式里为执行的时机 @Scheduled(cron = "0 34 13 * * ?") //每天的13点30分执行一次。 3、启动tomcat服务，定时任务就会按时执行。 关于CRON表达式 含义

定时任务的实现方式有多种，例如JDK自带的Timer+TimerTask方式，Spring 3.0以后的调度任务(Scheduled Task)，Quartz等。Timer+TimerTask是最基本的解决方案，但是比较远古了，这里不再讨论。Spring自带的ScheduledTask是一个轻量级的定时任务调度器，支持固定时间(支持cron表达式)和固定时间间隔调度任务，支持线程池管理。以上两种方式有一个共同的缺点，那就是应用服务器集群下会出现任务多次被调度执行的情况，因为集群的节点之间是不会共享任务信息的，每个节点上的任务都会按时执行。Quartz是一个功能完善的任务调度框架，特别牛叉的是它支持集群环境下的任务调度，当然代价也很大，需要将任务调度状态序列化到数据库。Quartz框架需要10多张表协同，配置繁多，令人望而却步...经过折中考虑，还是选择了Spring的Scheduled Task来实现定时任务。如下：1. Spring配置文件application-context.xml中添加task命名空间和描述。[html] view plain copy<beans xmlns="" xmlns:task="" xsi:schemaLocation=" /spring-beans.xsd /spring-task.xsd"> 2. 添加调度器和线程池声明。[html] view plain copy<task:executor id="taskExecutor" pool-size="10" /> <task:annotation-driven executor="taskExecutor" /> 3. 实现调度方法。基本结构如下：[html] view plain copypackage com.netease.yx.service; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; @Service public class ScheduledService { @Scheduled(cron = "0 0 5 * * *") public void build() { System.out.println("Scheduled Task"); } } @Scheduled注解支持秒级的cron表达式，上述声明表示每天5点执行build任务。前文已经提过，这种方式在单台应用服务器上运行没有问题，但是在集群环境下，会造成build任务在5点的时候运行多次，遗憾的是，Scheduled Task在框架层面没有相应的解决方案，只能靠程序员在应用级别进行控制。如何控制看1. 无非是一个任务互斥访问的问题，声明一把全局的逗锁地作为互斥量，哪个应用服务器拿到这把逗锁地，就有执行任务的权利，未拿到逗锁地的应用服务器不进行任何任务相关的操作。2.这把逗锁地最好还能在下次任务执行时间点前失效。在项目中我将这个互斥量放在了redis缓存里，1小时过期，这个过期时间是由任务调度的间隔时间决定的，只要小于两次任务执行时间差，大于集群间应用服务器的时间差即可。完整定时任务类如下：[html] view plain copypackage com.netease.yx.service; import javax.annotation.Resource; import org.apache.commons.lang3.time.DateUtils; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; import com.netease.yx.service.ICacheService; @Service public class ScheduledService { @Resource private ICacheService cache = null; private static String CACHE_LOCK = "cache_lock"; private static int EXPIRE_PERIOD = (int)DateUtils.MILLIS_PER_HOUR / 1000; @Scheduled(cron = "0 0 5 * * *") public void build() { if (cache.get(CACHE_LOCK) == null) { cache.set(CACHE_LOCK, true, EXPIRE_PERIOD); doJob(); } } }

首先要配置我们的spring.xmlxmlns 多加下面的内容、然后xsi:schemaLocation多加下面的内容、最后是我们的task任务扫描注解[html] view plaincopy<task:annotation-driven/> 我的配置扫描位置是：[html] view plaincopy<context:annotation-config/><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/><context:component-scan base-package="com.test"/> 扫描的是com.test这样的包下的内容、下面需要接口和实现（我的这几个java文件都是com.test的包下的、）[java] view plaincopypublic interface IMyTestService {public void myTest(); } [java] view plaincopy@Component //import org.springframework.stereotype.Component; public class MyTestServiceImpl implements IMyTestService {@Scheduled(cron="0/5 * * * * ? ") //每5秒执行一次@Overridepublic void myTest(){System.out.println("进入测试");} } 执行后控制台就会打印出 进入测试 了需要注意的几点：1、spring的@Scheduled注解 需要写在实现上、2、 定时器的任务方法不能有返回值（如果有返回值，spring初始化的时候会告诉你有个错误、需要设定一个proxytargetclass的某个值为true、具体就去百度google吧）3、实现类上要有组件的注解@Component

Spring RMI 有两个端口一个是注册端口（你所说的7099）还有个是数据传输端口，数据传输端口是随机分配的。当防火墙开启了7099是通的，其他端口被墙了！楼主可以网上搜 Spring RMI固定端口方法。~如果你认可我的回答，请及时点击【采纳为满意回答】按钮~~手机提问的朋友在客户端右上角评价点【满意】即可。~你的采纳是我前进的动力~~O(∩_∩)O，记得好评和采纳，互相帮助，谢谢。

HelloImpl是不是extends UnicastRemoteObject了？如果是的话去掉再试试

spring的rmi是RmiServiceExporter提供的一个服务。就是通过绑定一个url，比如绑定在 rmi://ip:1199/xx，客户端用这个url来链接服务，你说的关闭是什么意思？停止这个服务，还是？停止的话，你关闭这个端口就行了。

春意盎然 例句: 1. Spring is in the air, bringing with it angry thoughts about executive pay. 虽然春意盎然，但是空气中却弥漫着人们关于高层薪资的愤怒。 2. Now that spring is in the air, pretty girls are everywhere. 如今春天近在眼...

当请求发生时， DispatcherServlet 将请求递交给 hangler mapping, 让其检测请求并提出一个

resilience4j 是一款 java 平台轻量级容错库，支持熔断、限流、重试等功能。由于Netflix Hystrix 闭源，我们急需一款功能强大的容错工具库，来保护我们的环境。resilience4j 提供了spring boot 的starter，所以集成resilience4j很简单，但是也有一些坑。因此记录一下。 github： https://github.com/resilience4j/resilience4j 官方文档： https://resilience4j.readme.io/docs/circuitbreaker 我使用的是resilience4j 最新版本 0.16.0，spring boot 2.1.6。 相关依赖 </dependencies> 配置resilience4j，在spring 中的application.yml 中增加如下配置： resilience4j.circuitbreaker: instances: resilience4j.retry: instances: resilience4j.bulkhead: instances: resilience4j.thread-pool-bulkhead: instances: resilience4j.ratelimiter: instances: server: port: 9090 resilience4j 的配置在0.16.0 发生了一下变化。网上一些文档都是基于0.13.0版本。还有0.16.0版本配置不能被IDEA 识别，也不能自动联想，所以使用0.16.0版本尽量参考官网的配置。 配置介绍 注解 @CircuitBreaker(name = "backendA") code @Retry(name = "backendA") @CircuitBreaker(name = "backendA") @RateLimiter(name = "backendA") @Service public class ServiceA { } 多次失败达到阈值之后，再调用会抛出异常 io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker "backendA" is OPEN and does not permit further calls rest 调用返回结果： { } 这种情况可以配合spring aop，拦截异常，返回特性http 状态码或者信息，让前端捕获特定http 状态码，以此来呈现熔断之后的ui。 配置 注解 @RateLimiter(name = "backendA") code 同上 达到限制时抛出异常 io.github.resilience4j.ratelimiter.RequestNotPermitted: RateLimiter "backendA" does not permit further calls 经过试验，当@RateLimiter和@CircuitBreaker一起使用时,需要熔断器增加忽略RequestNotPermitted异常。否则会触发熔断。 ignoreExceptions: 其主要作用是限制并发次数 配置 注解 @Bulkhead(name = "backendA") 重试 配置 注解 @Retry(name = "backendA") resilience4j 为我们提供了很棒的容错库，简单易用。

你们家附近有大学吗？有的话可以去学校里面找英语专业的大学生做家教。一方面spring up 突然出现,涌现,迅猛发展即时训练: ①Doubts have began to spring

环境：Springboot2.3.12.RELEASE + cloud-netflix-hystrix2.2.10.RELEASE SpringCloud Circuit breaker(断路器)提供了跨不同断路器实现的抽象。它提供了在应用程序中使用的一致API，允许开发人员选择最适合应用程序需要的断路器实现。 支持的断路器类型： 要在代码中创建断路器（circuit breaker），可以使用断路器工厂API。当您在类路径中包含Spring Cloud Circuit Breaker starter时，将自动创建一个实现此API的bean。下面给出了使用此API的一个非常简单的示例： 通过引入下面不同依赖来确定使用具体的那个断路器 以上5种断路器是不同的实现方式，根据需要引入即可。 这里以Hystrix为例来使用 引入依赖 定义具有熔断功能的服务 Controller接口 CircuitBreakerFactory#create方法创建了CircuitBreaker实例 根据当前的CLASSPATH我们使用的是Hystrix，那么这里使用的工厂就是： HystrixCircuitBreakerFactory类 泛型参数：Setter就是用来配置Hystrix相关配置信息的（这里主要用来CommandKey与Setter进行绑定），HystrixConfigBuilder用来构建 HystrixCommand.Setter对象。 当执行HystrixCircuitBreakerFactory#configure方法时： 断路器具体的子类实现HystrixCircuitBreakerFactory 断路器工厂有了，接下来就是通过工厂创建具体的断路器对象了 通过上面的代码执行cbf().create("demo-slow")方法时执行了什么？ 上面创建的是HystrixCircuitBreaker断路器，当执行run方法时： 完毕！！！ 关注+转发 Sentinel 与 Hystrix 的对比 SpringCloud Hystrix实现资源隔离应用 SpringCloud Gateway 应用Hystrix 限流功能 自定义Filter详解 Spring Boot Security防重登录及在线总数 Spring Retry重试框架的应用 springboot mybatis jpa 实现读写分离 Spring容器对象BeanFactory与ApplicationContext你都清楚了吗？

　　Spring：　　Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。　　组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：　　核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。　　Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。　　Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。　　Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。　　Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。　　Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。　　Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。　　Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用　　Seasar2：　　在日本，Seasar2这个框架十分的流行。Seasar2其实就是类似于Spring的一个开源框架　　所谓“Seasar2”就是一个“轻量级容器”，面向无法摆脱“Java 应用开发”之烦恼的所谓“开发者”，它能够保证开发的“高生产率和高品质”。并且同“其它轻量级容器”不同的是，“完全不需要书写设定文件”，“就算是应用程序发生改动也无需再次起动即可直接识别变更，因此具有脚本语言的灵活性”。　　为了不用写设定文件也能够运行，Convention over Configuration的思想得以采用。Convention over Configuration就是指，“只要遵守一个适当的规约，即使不用进行非常麻烦的设定，框架结构也可以自动替我们搞定的思想”，这一思想是Ruby on Rails中所倡导的。Seasar2的Convention over Configuration是从Ruby on Rails 那里得到的提示而产生的。　　使用Seasar2的话，对于仅仅需要维护数据表这样简单的应用，可以在不到3分钟的时间里作成。　　应用程序发生改动之时也无需启动便可立即识别变更的机能在Seasar2里被称为HOT deploy。　　安装：　　S2需要安装JDK1.4 or JDK1.5。　　将S2xxx.zip解压之后的seasar2目录引入到Eclipse、「文件→导入→既存的工程」。

在JPA注解中，有个@Convert注解，其中需要传入一个Class作为convert参数，该class需要实现AttributeConverter<X,Y>接口。下面来看看AttributeConverter接口的作用。 实体属性类型转换器。主要使用场景： 简单化操作，用持久化enum枚举来进行一个操作。 AttributeConverter<X,Y> 该接口中需要实现两个方法： 场景：用户登录时，记录用户的动作：登录，登出，注册，重置密码。 数据的加密和日期的转换也就类似的操作了。 但是这样的每个枚举可能都要去写这样的转换类，可能会存在重复的操作。可以尝试写个通用的枚举转换类。

spring boot 怎么自动生成entity这个可以的 ，逆向工具 现在用的多的地方就是将模型转化为Entity，将Entity转化为模型。最好去找个开源插件。楼上的Hibernate tools，appfuse是比较好的选择。也可以自己开发一个。 自己写提供一个思路： 1.连接数据库 2.得到数据库的表结构，数据字段，类型 3.反向生成Entity类。 这个自己做一个简单的不难。最好是先用开源的，学学别人怎么做的。在改进。希望能帮到你！

一看名字，就是注解的一个实体类

给你个例子，实体类的注解代码如下：/** * 反事故措施 * * 使用JPA annotation定义ORM关系. 使用Hibernate annotation定义JPA 1.0未覆盖的部分. * * @author chen */@Entity// 表名与类名不相同时重新定义表名.@Table(name = "T_ACCIDENT_MEASURES")public class Accidents extends IdEntity { private String works; //应完成情况 private String worksed;//工作完成情况 private String jcstate; //检查状态 private String handleuser;//操作人 private String confuser;//部门审核 private String sjconfuser;//生计审核 private String tbtime;// 填报时间 private String zgstate;//整改状态 private String zgcs;//整改措施 private String zgwcqk;//整改完成情况 private String zgtime;//整改时间 private String zgr;//整改人 private String zgbmsh;//整改部门审核 private String zgysr;//整改验收 private String jdstate;//节点状态 private String isdel;//删除标志 1正常 2删除 private String bzhu;//备注 private String deptes; //部门 /** * @Lob适用于标注字段类型为Clob和Blob类型。 * Clob（Character Large Ojects）类型是长字符串类型， * 映射为实体中的类型可为char[]、Character[]、或者String类型。 * Blob（Binary Large Objects）类型是字节类型，映射为实体中的类型可为byte[]、Byte[]、 * 或者实现了Serializable接口的类。 * 因为这两种类型的数据一般占用的内存空间比较大，所以通常使用惰性加载的方式 * ，所以一般都要与@Basic标记同时使用，设置加载方式为FetchType.LAZY。 * @return */ @Lob @Basic(fetch = FetchType.LAZY)public String getWorks() { return works;}public void setWorks(String works) { this.works = works;}@Lob@Basic(fetch = FetchType.LAZY)public String getBzhu() { return bzhu;}public void setBzhu(String bzhu) { this.bzhu = bzhu;}public String getDeptes() { return deptes;}public void setDeptes(String deptes) { this.deptes = deptes;}public String getJcstate() { return jcstate;}public void setJcstate(String jcstate) { this.jcstate = jcstate;}public String getHandleuser() { return handleuser;}public void setHandleuser(String handleuser) { this.handleuser = handleuser;}public String getConfuser() { return confuser;}public void setConfuser(String confuser) { this.confuser = confuser;}public String getZgstate() { return zgstate;}public void setZgstate(String zgstate) { this.zgstate = zgstate;}public String getTbtime() { return tbtime;}public void setTbtime(String tbtime) { this.tbtime = tbtime;}public String getZgtime() { return zgtime;}public void setZgtime(String zgtime) { this.zgtime = zgtime;}public String getJdstate() { return jdstate;}public void setJdstate(String jdstate) { this.jdstate = jdstate;}public String getIsdel() { return isdel;}public void setIsdel(String isdel) { this.isdel = isdel;}public String getWorksed() { return worksed;}public void setWorksed(String worksed) { this.worksed = worksed;}public String getSjconfuser() { return sjconfuser;}public void setSjconfuser(String sjconfuser) { this.sjconfuser = sjconfuser;}public String getZgcs() { return zgcs;}public void setZgcs(String zgcs) { this.zgcs = zgcs;}public String getZgwcqk() { return zgwcqk;}public void setZgwcqk(String zgwcqk) { this.zgwcqk = zgwcqk;}public String getZgr() { return zgr;}public void setZgr(String zgr) { this.zgr = zgr;}public String getZgbmsh() { return zgbmsh;}public void setZgbmsh(String zgbmsh) { this.zgbmsh = zgbmsh;}public String getZgysr() { return zgysr;}public void setZgysr(String zgysr) { this.zgysr = zgysr;}public Accidents() { super();}}

the winter is coming and the spring is not far这句话的翻译是：冬天来了,春天不远了。

你可以把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的工作流程和一些关键的类,但是并没有去深入的去探讨它背后所体现的思想,还有它的优缺点等东西.这些都等下次再说吧

jsf不太清楚，目测是种框架，spring是struts2 里的，具体我还没学到，struts1和2没啥联系，1主要是MVC吧，2就是SSH了。希望对你有帮助。

从Struts2的发展过程来看，Struts2继承了Struts与WebWork的血脉，Struts2取两者之精华，形成新德框架，但是struts2还是更多的继承了struts的设计思想，并加入了WebWork的优点。在了解Struts2体系之前，让我们先看看struts2对struts做了哪些修改。Struts2与struts的不同主要体现在以下几个方面。（1） Action类1》在struts中都是使用抽象类编程而不是接口，因此他要求开发Action类继承一个抽象的基类，如DispatchAction等。2》Struts2则基于接口编程，我们的Action类可以实现一个Action接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。更加强大的是，在struts2中Action接口不是必需的，任何有execute()函数的pojo对象都可以用作struts2的Action类来使用。（2） 线程模式1》 struts的Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单列策略限制了struts Action能做的事，并且要在开发时特别小心，Action资源必须是线程安全的或同步的；2》 struts2的Action对象为每一个请求产生一个实例，因此没有线程安全问题。（3） Servlet依赖1》 struts的Action依赖于Servlet API，当一个Action被调用时，HttpServletRequest和HttpServletResponse被传递给执行方法，例如：publicActionForward execute(Actionmapping mapping,ActionForm Form,HttpServletRequestrequest,HttpServletResponse response){}2》 struts2的Action不依赖与容器，允许Action脱离容器单独被测试。如果需要，Struts2的Action任然可以访问初始的request和response。例如下面的这个类MyAction.Java，他可以通过ActionContext对象取得Session值，也可以通过ServletActionContext对象取得request对象。Publicclass MyAction{ protected Object getSession(String key){ return ActionContext.getContext().getSession(key);}protectedHttpServletRequest getRequest(){return(String)ServletActionContext.getRequest();}}（4） 可测试性1》 测试Struts Action的一个主要问题是，execute（）方法暴露了Servlet API，这使得测试要依赖于容器。虽然有第三方的软件struts TestCase能够使用模拟对象来进行测试，但显然会让我们的测试变得更加复杂。2》 Struts2 Action的类是POJO对象，因此可以直接编写测试类来测试Action类，只需要在测试类中注入属性即可。（5） 捕获输入1》 struts使用ActionForm对象捕获用户输入，所有的ActionForm必须继承一个基类ActionForm。因为其他的JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态表单可以作为创建传统ActionForm的选择，但是，开发者可能是再创建已经存在的JavaBean，仍然会导致有冗余的JavaBean；2》 struts2直接使用Action属性作为输入属性，消除对第二个输入对象的需求。输入属性可能是有自己子属性的rich对象类型。Action属性能够通过Web页面的taglibs访问。同时，struts2也支持ActionForm模式。（6） 表达式语言1》 struts整合了JSTL，这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱2》 struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言OGNL（7） 绑定值到页面1》 struts使用标准jsp机制把对象绑定到页面中来访问2》 struts2使用ValueStack（值堆栈）技术，使taglib能够访问值，而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）（8） 类型转换1》 struts的ActionForm属性通常都是String类型，并不使用 Commons-Beanutils进行类型转换。每个类提供一个转换器，对每个实例来说是不可配置的；2》 struts2使用OGNL进行OGNL进行类型转换，提供了基本和常用对象转换器。（9） 数据校验1》 struts支持在ActionForm的Validate方法中手动校验，或者通过Commons Validator来扩展校验。同一个类可以有不同的校验内容，但不能校验子对象；2》 struts2支持通过validata（）方法和XWork校验框架来进行校验，XWork校验框架使用为属性类型定义的校验和内容校验，来支持chain校验子属性。（10） Action执行的控制1》 struts支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须提供相同的生命周期；2》 struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期，堆栈能够根据需要和不同的Action一起使用

1、首先确定知识图谱的数据源。2、其次在springboot项目中，导入相应的知识图谱相关依赖库。3、最后配置数据源连接信息就可以集成了。

1)不要谈论1)春天。核心的ioc、aop技术和ioc解耦使得代码重用性和可维护性大大提高。aop提供了前沿的编程，这也提高了生产率。2)spring mvc，相比struts2等mvc框架，不提struts2有那么多安全漏洞，就是类拦截。所有的动作变量都是共享的，同时，它是过滤器入口。spring mvc是方法拦截，控制器独享请求响应数据。采用的serlvet入口与spring无缝连接。在开发方面，spring mvc更轻量级，更低入口。3)mybatis。看业务场景，主要是mybatis的sql可以被开发者控制和调优。与hibernate等orm框架相比，更加直观。当业务场景复杂，sql相互关联，谁用mybatis谁知道。当然缺点是对sql不熟悉的开发者不太友好。两者的对比有点奇怪。因为SSM是一个WEB使用框架，覆盖整个使用层，而spring boot可以看作是一个启动、配置、快速开发的辅助框架，是针对微服务的。Springboot只是为了提高开发效率，而且是为了提高生产力：1.springboot一个使用是一个可执行的jar(启动类的main方法来启动web使用)，不像传统的war嵌入了tomcat容器。它可以以jar的形式启动服务，并快速部署和发布web服务。微服务是最好的。2.将原始的xml配置简化为java配置。3.当然，结构可能与一般的ssm不同，但主要是在资源文件中。Spring Boot默认“约定”从资源目录的这些子目录中读取静态资源：(转自开源中国)相关问答：springboot内置tomcat并发多少SpringBoot内置Tomcat，在默认设置中，Tomcat的最大线程数是200，最大连接数是10000。支持的并发量是指连接数。Tomcat有两种处理连接的模式，一种是BIO，一个线程只处理一个连接，另一种就是NIO，一个线程处理多个连接。由于HTTP请求不会太耗时，而且多个连接一般不会同时来消息，所以一个线程处理多个连接没有太大问题。因此，200个线程处理10000条连接完全ok。默认值可以在spring-boot-autoconfigure-x.x.x 包中看到。相关问答：springboot项目打包成war用tomcat运行好还是打包成jar直接启动好？为何？谢谢邀请！我将从以下几点回答你的问题1、打成jar包步骤2、打成war包步骤3、jar 包 启动和war包启动的区别？打成jar包步骤1、指定打成jar包的名称右键项目-Run maven - install那么如果项目中出现多个主启动类怎么办?在pom中指定主启动类使用jar -jar 包名打成war包的步骤1、指定Springboot pom中的打包方式，jar改成war2、在spring-boot-starter-web模块打包需要依赖的 tomcat3、在主启动类上 实现SpringBootServletInitializer 重写configure方法打包：将war包放入tomcat webapps 下运行即可；注意:springboot2.0内置tomcat8.5.25，建议使用外部Tomcat9.0版本运行即可,否则报错版本不兼容。打包常见错误如果报错没有主清单,在pom文件中新增Java jar 执行的时候报错 " 不是内部或外部命令 说明 jdk环境没有安装 jar包运行和war包运行的区别？SpringBoot 既可以打成war包，也可以打成jar包，有以下区别？1、jar包： 直接通过内置tomcat运行，不需要额外的tomcat 容器，如果要修改tomcat参数，则直接在applicaiton.properties 文件中配置即可，内置的tomcat 没有自己的输出日志。jar包运行比较方便、快捷，比较简单。2、war包：需要安装tomcat ，然后将war包放入webapps下运行，可以灵活选择tomcat版本，也可以直接修改tomcat的配置，有自己的输出日志，可以配置自己的安全策略。相对于jar包来说比较灵活。如果我们希望一个tomcat来管理多个项目或者使用jetty/netty等其它web服务器，这种情况下就要使用war包。如果你使用的还是JSP,因为jsp只能够在war包中使用，直接使用jar运行还是tomcat运行，我个人比较war包。但是使用什么方式区别不大，看自己的习惯和场景。

使用springMVC作为系统的整体基础架构，负责MVC的分离，在springMVC框架的模型部分，控制业务跳转，利用mybatis框架对持久层提供支持，Spring做管理，管理springMVC和mybatis。

springboot和ssm不冲突,springboot只是简化了配置,实际开发 没什么区别.SSM就好像开手动挡的汽车,需要踩离合,挂档,给油车才能开动.而springboot就好像自动挡的汽车,给油就走,踩刹车就停.一、Springboot和SSM的区别.在开发中的区别还是存在的,虽然springboot简化了配置,但并不代表不需要编写配置文件,还是需要在自带的application.yml文件中去编写一些内容.只不过编写的方式变得简单了,虽然简单了,但是和SSM整合的方式还有些区别.在使用SSM开发的时候,多数会选择Jsp作为视图,但是springboot不推荐使用jsp,主推的是thymeleaf和freemarker等模板引擎,也造成了使用SSM开发到springboot开发也需要一定得学习成本.不过如果掌握了SSM的话,学习springboot也是水到渠成,异常的简单.二、推荐springboot.更推荐使用springboot开发,一是springboot工具集的简化配置等操作,可以让程序员把精力主要放在代码的业务逻辑上,二是想学习springcloud微服务组件的话,springboot是基础.

springMVC，是spring的一个子框架，当然拥有spring的特性，如依赖注入SpringMVC 是类似于 Struts2 的一个 MVC 框架，在实际开发中，接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示，但是上手难度却比 Struts2 简单多了。而且由于 Struts2 所暴露出来的安全问题，SpringMVC 已经成为了大多数企业优先选择的框架。springMVC的DispatcherServlet继承自 FrameworkServlet继承自HttpServletBean 继承自HttpServlet（也就是你说的servelt） 本质上是一样的东西。一句话就是高级版的servlet.SSH和SSM定义SSH 通常指的是 Struts2，Spring ，Hibernate。SSM 则指的是 SpringMVC，Spring，MyBatisSSH 通常指的是 Struts2 做前端控制器，Spring 管理各层的组件，Hibernate 负责持久化层。SSM 则指的是 SpringMVC 做前端控制器，Spring 管理各层的组件，MyBatis 负责持久化层。共同之处是都使用了Spring的依赖注入DI来管理各层的组件，使用了面向切面编程AOP来实现日志管理，权限认证，事务等通用功能的切入。不同之处是 Struts2 和 SpringMVC 做前端控制器的区别，以及 Hibernate 和 MyBatis 做持久化时的区别。但是，Struts2 也可以和 MyBatis 搭配使用，SpringMVC 也可以和 Hibernate 搭配使用。本文为了简化对比，指定 Struts2 要和 Hibernate 搭配，SpringMVC 要和 MyBatis 搭配。

SSM框架是java热门技术框架，并没有落后，反而十分重要。SSM框架是Java核心知识之一。SSM（Spring+SpringMVC+MyBatis）框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。常作为数据源较简单的web项目的框架。Spring就像是整个项目中装配bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。也可以称之为项目中的粘合剂。Spring的核心思想是IoC（控制反转），即不再需要程序员去显式地`new`一个对象，而是让Spring框架帮你来完成这一切。SpringMVC在项目中拦截用户请求，它的核心Servlet即DispatcherServlet承担中介或是前台这样的职责，将用户请求通过HandlerMapping去匹配Controller，Controller就是具体对应请求所执行的操作。SpringMVC相当于SSH框架中struts。

统筹管理的作用。SSM框架是spring、spring MVC和mybatis框架的整合，是标准的MVC模式，将整个系统划分为四层：表现层，controller层，service层，DAO层。简介Spring是一个开源框架，是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。Spring MVC分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

通过注解获取（很简单，推荐）： public class Hello { @Autowired HttpServletRequest request; //这里可以获取到request }2.在web.xml中配置一个监听： org.springframework.web.context.request.RequestContextListener java代码Spring BootSpring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

目前市场上主流的 第一套微服务架构解决方案：Spring Boot + Spring Cloud Netflix Spring Cloud 为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调导致了样板模式, 使用 Spring Cloud 开发人员可以快速地支持实现这些模式的服务和应用程序。他们将在任何分布式环境中运行良好，包括开发人员自己的笔记本电脑，裸机数据中心，以及 Cloud Foundry 等托管平台。 目前业界对 Spring Cloud 使用最广的就是 Spring Cloud Netflix 了。后来 采用 Spring Cloud Alibaba 方案来替代 Spring Cloud Netflix 【官方新闻】Spring Cloud Greenwich.RC1 available now 2018 年 12 月 12 日，Netflix 宣布 Spring Cloud Netflix 系列技术栈进入维护模式（不再添加新特性） 最近， Netflix 宣布 Hystrix 正在进入维护模式。自 2016 年以来， Ribbon 已处于类似状态。虽然 Hystrix 和 Ribbon 现已处于维护模式，但它们仍然在 Netflix 大规模部署。 Hystrix Dashboard 和 Turbine 已被 Atlas 取代。这些项目的最后一次提交分别是 2 年前和 4 年前。 Zuul1 和 Archaius1 都被后来不兼容的版本所取代。 以下 Spring Cloud Netflix 模块和相应的 Starter 将进入维护模式： 将模块置于维护模式，意味着 Spring Cloud 团队将不会再向模块添加新功能。我们将修复 block 级别的 bug 以及安全问题，我们也会考虑并审查社区的小型 pull request。 我们建议对这些模块提供的功能进行以下替换 并发限制模块，它是 Netflix 开源的限流器项目，Spring Cloud 在 Greenwich 版本中引入 spring-cloud-netflix-concurrency-limits 有些人对它可能比较陌生，也是 Netflix 公司开源项目，基于 Java 的配置管理类库（apache common configuration 类库的扩展），主要用于多配置存储的动态获取。它主要的特性： 目前还中孵化中，Spring 可能是要抽象一个断路器的统一规范，让不同的断路器（Hystrix、Resilience4j、 Sentinel（阿里开源） ）选择使用 Spring Boot 2 中的 Spring Boot Actuator 底层用的就是 Micrometer，它是 Pivotal 公司（也就是 Spring 所在的公司）开源的监控门面，类似于监控世界的 Slf4j。 Resilience4j 自带整合了 Micrometer ；目前还无法判断是否比 Hystrix Dashboard /Turbine 的更强大，更好用。 目前还中孵化中，使用上和 Ribbon 区别不大 Zuul 持续跳票 1 年多，1.x 是一个基于阻塞 IO 的 API Gateway 以及 Servlet；直到 2018 年 5 月，Zuul 2.x（基于 Netty，也是非阻塞的，支持长连接）才发布，但 Spring Cloud 暂时还没有整合计划。Spring Cloud Gateway 比 Zuul 1.x 系列的性能和功能整体要好。 Netflix 开源的组件（Archaius 1/Ribbon/Hystrix）都没有使用 Spring Boot 的规范（spring-boot-configuration-processor），根本没有 metadata.json 文件，于是这部分配置 IDE 无法给你提示

SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是springboot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，springboot整合了所有的框架。　　　　SpringBoot框架，它的作用很简单，就是帮我们自动配置。SpringBoot框架的核心就是自动配置，只要存在相应的jar包，Spring就帮我们自动配置。如果默认配置不能满足需求，我们还可以替换掉自动配置类，使用我们自己的配置。另外，SpringBoot还集成了嵌入式的Web服务器，系统监控等很多有用的功，让我们快速构建企业及应用程序。　　　　

SpringBoot是Pivotal团队在spring框架基础上开发的框架，设计目的是简化应用的初始搭建以及开发过程。SpirngBoot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具.SpringBoot以约定大于配置的核心思想，从而使开发人员不再需要定义样板化的配置。时它集成了大量常用的第三方库配置（例如Redis，MongoDB，JpaRabbitMQ，Quartz等等），SpringBoot应用中这些第三方库几乎可以零配置的开箱即用。

碟形弹簧（belleville spring）又名贝勒维尔弹簧垫圈，最早是100多年前法国J. Belleville发明。碟形弹簧的形状为圆锥碟状，与传统弹簧不同，功能上有其特殊的作用，主要特点是，负荷大，行程短，所需空间小，组合使用方便，维修换装容易，经济安全性高。适用于空间小，负荷大之精密重机械。其压缩行程最佳使用范围在其最大压缩行程的10%-75%之间。

只是记得春天向前,后退。

Falling In Love~Spring loll恋爱~春天懒洋洋外春暖花开、阳光明媚，室内人们却哈欠连连，提不起精神。春困就像传染病，工作量没增加、睡眠没减少，竟然觉得劳顿无比。到春天的环境很有特点，和风拂柳，花粉纷飞……为此，不少过敏体质的人群在这一季节易旧病复发，如皮炎、哮喘、支气管炎等。但鲜有人知，表现为头脑昏昏沉沉的春困，也是多种过敏症状中的一种。

Because I think itu2019s interesting

C C 考察虚拟语气和倒装。句义：母亲提醒：要是下雨，就带上雨伞吧！由于春天到了。根据语境可知母亲的提醒是对未来情况的假设。故使用If sth/sb should +动词原形。其中的if省略，可将should提前，构成倒装句。故C正确。

一、序列化和反序列化的概念　　把对象转换为字节序列的过程称为对象的序列化。　　把字节序列恢复为对象的过程称为对象的反序列化。　　对象的序列化主要有两种用途：　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；　　2） 在网络上传送对象的字节序列。　　在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。　　当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。二、JDK类库中的序列化API　　java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。　　java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。　　只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。　　对象序列化包括如下步骤：　　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；　　2） 通过对象输出流的writeObject()方法写对象。　　对象反序列化的步骤如下：　　1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；　　2） 通过对象输入流的readObject()方法读取对象。对象序列化和反序列范例：　　定义一个Person类，实现Serializable接口1 import java.io.Serializable; 2 3 /** 4 * <p>ClassName: Person<p> 5 * <p>Description:测试对象序列化和反序列化<p> 6 * @author xudp 7 * @version 1.0 V 8 * @createTime 2014-6-9 下午02:33:25 9 */10 public class Person implements Serializable {11 12 /**13 * 序列化ID14 */15 private static final long serialVersionUID = -5809782578272943999L;16 private int age;17 private String name;18 private String sex;19 20 public int getAge() {21 return age;22 }23 24 public String getName() {25 return name;26 }27 28 public String getSex() {29 return sex;30 }31 32 public void setAge(int age) {33 this.age = age;34 }35 36 public void setName(String name) {37 this.name = name;38 }39 40 public void setSex(String sex) {41 this.sex = sex;42 }43 }　　序列化和反序列化Person类对象1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileNotFoundException; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 import java.text.MessageFormat; 9 10 /**11 * <p>ClassName: TestObjSerializeAndDeserialize<p>12 * <p>Description: 测试对象的序列化和反序列<p>13 * @author xudp14 * @version 1.0 V15 * @createTime 2014-6-9 下午03:17:2516 */17 public class TestObjSerializeAndDeserialize {18 19 public static void main(String[] args) throws Exception {20 SerializePerson();//序列化Person对象21 Person p = DeserializePerson();//反序列Perons对象22 System.out.println(MessageFormat.format("name={0},age={1},sex={2}",23 p.getName(), p.getAge(), p.getSex()));24 }25 26 /**27 * MethodName: SerializePerson 28 * Description: 序列化Person对象29 * @author xudp30 * @throws FileNotFoundException31 * @throws IOException32 */33 private static void SerializePerson() throws FileNotFoundException,34 IOException {35 Person person = new Person();36 person.setName("gacl");37 person.setAge(25);38 person.setSex("男");39 // ObjectOutputStream 对象输出流，将Person对象存储到E盘的Person.txt文件中，完成对Person对象的序列化操作40 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(41 new File("E:/Person.txt")));42 oo.writeObject(person);43 System.out.println("Person对象序列化成功！");44 oo.close();45 }46 47 /**48 * MethodName: DeserializePerson 49 * Description: 反序列Perons对象50 * @author xudp51 * @return52 * @throws Exception53 * @throws IOException54 */55 private static Person DeserializePerson() throws Exception, IOException {56 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(57 new File("E:/Person.txt")));58 Person person = (Person) ois.readObject();59 System.out.println("Person对象反序列化成功！");60 return person;61 }62 63 }

springmvc登录验证使用db校验：import java.util.ArrayList;import java.util.Collection;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.authority.SimpleGrantedAuthority;import org.springframework.security.core.userdetails.User;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.core.userdetails.UserDetailsService;import org.springframework.security.core.userdetails.UsernameNotFoundException;import org.springframework.stereotype.Repository;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import UserBean;@Repository@Service@Transactional(readOnly=true)public class SimpleUserDetailsService implements UserDetailsService {@Autowiredprivate UserDao userDAO;private UserBean domainUser; public UserDetails loadUserByUsername(String login)throws UsernameNotFoundException {domainUser = userDAO.getUser(login);boolean enabled = true;boolean disabled = false;boolean accountNonExpired = true;boolean accountExpired = false;boolean credentialsNonExpired = true;boolean credentialsExpired = false;boolean accountNonLocked = true;boolean accountLocked = false;if (null != domainUser){return new User(domainUser.getUsername(), //getLogin(),domainUser.getPassword(),enabled,accountNonExpired,credentialsNonExpired,accountNonLocked,getAuthorities(domainUser.getIduser() ) );} else {return new User("**20**","**//**",disabled,accountExpired,credentialsExpired,accountLocked,getAuthorities(-20 ) ) ;}}public Collection<? extends GrantedAuthority> getAuthorities(Integer userid) {List<GrantedAuthority> authList = getGrantedAuthorities(getRoles(userid));return authList;}public List<String> getRoles(Integer userid) {List<String> roles = new ArrayList<String>();roles = userDAO.getUserRoles(userid);return roles;}public static List<GrantedAuthority> getGrantedAuthorities(List<String> roles) {List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();for (String role : roles) {authorities.add(new SimpleGrantedAuthority(role));}return authorities;}

　Spring Security原名是Acegi Security;类别为安全服务体系;所属Spring 项目;是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。提供了一组可以在Spring应用上下文中配置的Bean,充分利用了Spring IoC,DI(控制反转Inversion of Control,DI:Dependency Injection 依赖注入)和AOP(面向切面编程)功能,为应用系统提供声明式的安全访问控制功能,减少了为企业系统安全控制编写大量重复代码的工作。　　　　spring security实现用户注册的方法如下步骤操作：　　将前台用户和后台管理用户，设置在同一登录页面登录，进行身份验证。　　applicationContext-security.xml的设置如下：　　<http auto-config="true" use-expressions="true">　　<!--设置登录页面和登录处理，及验证失败的url-->　　<form-login login-processing-url="/user/j_spring_security_check" login-page="/userlogin" authentication-failure-url="/userlogin?login_error=t" />　　<!--设置注销用户的url-->　　<logout logout-url="/user/j_spring_security_logout" logout-success-url="/user/"/>　　<!--设置匹配前台用户url，所拥有的权限-->　　<intercept-url pattern="/user/**" access="hasRole("ROLE_USER")"/>　　<!--设置匹配后台管理用户url，所拥有的权限-->　　<intercept-url pattern="/admin/**" access="hasRole("ROLE_ADMIN")"/>　　</http>　　<!--设置验证管理-->　　<authentication-manager alias="authenticationManager">　　<!--可根据需求，设置验证提供者-->　　<authentication-provider>　　<user-service>　　<user name="root" authorities="ROLE_ADMIN" password="root" />　　<user name="admin" authorities="ROLE_ADMIN" password="admin" />　　<user name="tonyzhao" password="tonyzhao" authorities="ROLE_USER" />　　<user name="mr_zyf@163.com" password="mr_zyf@163.com" authorities="ROLE_USER" />　　</user-service>　　</authentication-provider>　　</authentication-manager>　　Spring Security 的前身是 Acegi Security ，是 Spring 项目组中用来提供安全认证服务的框架。Spring Security 为基于J2EE企业应用软件提供了全面安全服务。特别是使用领先的J2EE解决方案-Spring框架开发的企业软件项目。

像一只春天的鸟

春天花会开，鸟自由自由自在。你金币是掉了一地吧……

The Four seasons A year has four seasons. Every season has three months. The weather of one season is different from that of any other. The life cycles of plants are controlled by the seasons. The first season is spring. The three months in it are March, April and May. During that time we have warm weather and fine days. All plants e to life. Animals wake up from hibernation. It is time for farmers to get ready for their fields. The second season is summer. The three months are June, July and August. The weather is very hot and it often rains. People can go swimming and sightseeing. It is time for all things to grow up. The third season is autumn. The three months are September, October and November. The weather bees cooler and cooler. Leaves begin to fall to the ground. It is the harvest time for farmers. The fourth season is winter. December, January and February are the three months of that season. The weather is very cold, and most of the plants die at that time. Sometimes it snows. People can enjoy skating and skiing. But winter doesn" t stay with us for a long time, for spring es again soon. 四季 一年有四季,每个季节有三个月,每个季节的气候都不一样.生命的轮回由四季控制. 第一个季度是春季.春季的三个月为三月、四月和五月.在这段时间里,天气温暖、晴朗,万物复苏.冬眠的动物们也醒过来了,农民们开始忙农活. 第二个季节是夏季,包括六月、七月和八月.天气非常热,而且老是下雨.人们能游泳、观光.夏季也是万物生长的好时候. 第三个季节是秋季,三个月分别是九月、十月和十一月.天 气越来越凉,树叶开始飘落.这是一个收获的季节. 最后一个季节是冬季,这一季包括十二月、一月和二月.天气非常冷,大多数植物都死了.有时候还下雪,人们可以滑冰和滑雪.但是冬天不会太长,因为春天马上就要来临了.,1,

面对朝大海，春暖花开。

分层架构是一个非常通用和抽象的范式，消息系统非常符合同样抽象的“管道和过滤器”模型。“过滤器”代表任何能够生产和（或）消费消息的组件，“管道”在过滤器间传输消息，所以组件间保持松耦合。 消息：在Spring Integration中，消息是任何Java对象连同框架处理对象时使用的元数据的一个通用包装。它由负载和头部组成。负载可以是任何类型，头部保存一般的请求信息。

使用入门企业应用集成速成我们实际构建一个非常普通的应用，以此来演示开发周期。该示例易于理解，但却没有斧凿之嫌。此外，它还是一个很酷的工具。需求是：允许通过电子邮件将博客发送到一个已知地址，然后由该地址发布博客。这么做有一些好的理由。Blogger（[10]Google的博客服务）已经有这个功能。但我在我博客上运行Apache Roller（[11]），所以我可以使用这个解决方案。写博客的惰性很大程度上是没时间进入“发布”模式的副作用。Roller的软件强迫用户登录并撰写博客文章。这么做很麻烦，尤其是你每次都不得不对付WYIWYG（所见即所得）编辑器。第二，构建该解决办法最好的理由是，它提供了了一种简单的集成，能与尽可能少的运转部分集成在一起。我们可以在本文中仔细分析该办法。尽管这是假设的，但很有实际用途。构建集成非常简单，最好的“IDE”只是一张纸和一支笔。可以在很多工具中画图。将图转换成你喜欢的ESB配置格式或工具非常简单。ESB使用相同的术语。了解术语要比了解任何一种工具或ESB更为重要。让我们回顾一些ESB 101定义，权当补习了。消息是传递到端点的有效负载。端点是通道的终点。通道是两个端点间被命名的连接。通常，消息来自于消息系统，被分发到不了解消息系统的应用中。同样的事情或者会反过来以其它方式出现：应用可能会发送数据，但并不理解消息系统。针对这些问题，就需要通道适配器了。就是这样！这些就是你需要了解的条目，以便讨论解决方案。其它条目都是这些条目之上的变异或详细说明，或者是关于集成模式的，而不是关于集成本身。Spring Integration概况Spring Integration应用就是使用Spring schema配置的简单Java程序。如果你倾向于用常规的Spring配置来配置一切，就可以不使用schema。Schema会使事情更为简单，这和用schema配置使用Spring中方面的事务功能会更加简单大致一样。Spring Integration为一般概念（集成命名空间）提供了方便的schema，还有适配器的具体配置，比如针对电子邮件或文件类型的配置。Spring Integration应用处理从通道传递过来的消息概念。消息的生命周期始于一个端点，通常是对适配器做出的反应。消息在经过处理管道的过程中，会在总线内被转化、路由至其它通道、分发、响应，或者被中断并发送到一个死消息通道中去。如果你使用Spring Integration接口编程——我们将在很大程度上尽可能保持内容一致并明确，那你要处理Message对象，Message对象如图1所示。Message类是个包装器，包装被处理消息的有效负载。对它进行操作，很容易获得有效负载和消息头，你可以对有效负载进行类型转换，可以检查、改变消息头。Spring Integration不要求你使用Message接口。你的应用可以暴露一些方法，这些方法的参数类型跟你消息有效负载的类型相同。比如说，来自于文件适配器（可以从文件系统发送消息的适配器）的消息可能会被改为java.io.File实例。让我们来看一个集成例子，它把电子邮件发送到一个电子邮件地址，转换电子邮件后再将其发布到博客中。示例的配置在src/main/resources/integrationsContext.xml中。全部源码可以从这里下载。integrationsContext.xml文件乍看起来很平常。XML顶端的bean负责将属性文件中的变量宏替换到该XML配置脚本中。后面导入了另一个Spring文件，该文件包含本集成中要使用的简单服务。再没什么特别的了。接下来继续看相继定义的四个bean，它们还是有意思的：服务催化器newBlogPublishingServiceActivator、转换器 emailToBlogTransformer、处理器outboundBlogPostHandler和过滤器 emailsInFilterAgainstWhitelist。这四个bean会在配置的后面部分里用到。实质配置的第一段是poller元素，它是文档的默认轮询器。确切来说，轮询器是一种机制，在有变化时轮询不同端点，并在感知到某些内容发生变化后让适配器对其做出响应，就像一个事件。出于简单，我们为整个Spring Integration配置一个默认的轮询器。见图2。接下来的三个元素是三个通道声明。他们毫无意义，只是命名的通道而已。没有端点或适配器的通道毫无用处。见图3。下一行配置了电子邮件适配器。电子邮件适配器查找发入系统的电子邮件，并将其放入名叫emailsIn的通道，该通道已经在上面定义了。电子邮件发进来时，电子邮件系统并不会播报事件。在出现异常的时候（比如Spring Integration也支持的IMAP IDLE），你通常需要一些东西来轮询电子邮件帐户以查找新的电子邮件。只要有新消息，它们就一次阅读一条消息，并将该消息传递到处理管道的下一个组件。见图4。现在消息在emailsIn通道中传递，被传递到通道的下一个组件——转换器bean。转换器获取所有给它的内容，以某种方式改变消息（我们稍后会详细讨论这一点），然后顺便发送出去。这种情况下，会给Transformer给定一个包含MimeMessage类型有效负载的Message，转化器用于创建BlogPost类型的一个对象。BlogPost是我们系统特定的一个领域类。我们在这里把它作为DTO来用，但很显然，它来自哪里并不重要 ——如果你愿意，根据你的领域去处理它也可以。Transformer元素的最佳用法是：将消息格式转换为系统常见的格式。这跟标准数据模式相关。由此产生的BlogPost封装在一条新消息中，其中包含原始消息的头信息。头信息正是你期望的那样：特定于请求的值，可以对其访问以获取更多的元数据。例如，从内部来说，Spring Integration总线给每样内容分配一个ID。该ID暴露为头信息值供你使用。该ID保证是唯一的。然后消息被发送给过滤器emailsInFilterAgainstWhitelist，该过滤器访问有效负载获取发送者的值。这样做是为了确保在发布到博客的过程中你不会收到垃圾邮件。这个例子跟整个解决方案一样，简单的有些不合常理。你可以想象是去查询Spring安全或LDAP，或是比这个做得还要好的东西。见图5：XML配置的最后一段内容是service-activator元素，它获取所有给它的内容并进行处理。在这种情况下，我们告知Spring Integration调用ID为newBlogPublishingServiceActivator的bean的 pubishIncomignBlogEntry方法。该方法负责实际获取有效负载，并将有效负载发送给发布博客条目的服务。然后我们就大功告成了。内容看起来很多，但实际上就是相关XML的四段内容。声明通道是为了讲清楚例子。poller元素只定义了一次，这样，上下文中需要轮询器的所有内容都可以利用这个缺省的轮询器了。可能的扩展我们定义了三个通道、四个组件。通过这样设计构成解决方案的组件，我们能让这些组件在其它集成解决方案中可以重用。集成流程不仅仅限于此示例。我们可能会在更复杂的集成中重用转换器、过滤器，甚至是服务催化器。唯一需要重构的是Spring Integration XML文件。有很多可能性。一个好的ESB应该做到：尽可能晚地重构流程设计和配置。这里我们很容易就能想象到可以在什么地方采用该解决方案。下面是一些可能的补充。对于某些审计工作流，使用jBPM（[12]）对系统增加支持。假设我们想在解决方案中添加业务流程管理（BPM），比如在消息传入时，以某种工作队列的分类存储该消息，以便编辑器进行核准。编辑过程可以处理得跟工作流引擎内部要求的一样。最终的博客内容核准后，编辑器把定稿发送到同样的电子邮件地址，带着某种关键字或识别出能用作相关ID的关键字。相关ID可用来让集成解决方案继续进行，主要表现在更新的条目。见[13]。使用Spring Integration“组播”博客。当然，博客已经发布了。但还有一个问题，用旧的哲学问题来描述再合适不过了：“如果在woods中RSS订阅已经更新了，而没有人轮询到它，那博客算真正更新了吗？”呃，也许我只是讲了大概的意思！也可以通过Twitter传播博客标题，可以使用接收者列表模式（[16]）通知博客聚合器（[14]、[15]等）。更新过滤器例子来验证某种真正授权的服务。也许能使用LDAP或Spring安全。除了简单的电子邮件之外，多样化对发布的支持。FTP、 WebDav、文件系统（在源码中，电子邮件适配器的下面注释了一个简单的文件目录适配器配置）等都是可行的输入类型。更先进的例子则可以从移动客户端发送SMS消息。（当然，我不确定有多少人用他们的手机写博客。你永远也不会知道。不过只有一种方式能找到答案。）目前还没有对此的支持，但阅读了 Spring Integration的源码后会发现，很容易构建自己的适配器。你可以使用SMSLib[17]类似的库。Spring Integration的不足之处Spring Integration是全新且强大的。你可以对其背后的SpringSource的价值及其自身的不断发展抱有信心。但这并不意味着它是完美的——它离完美还远着哩！应用集成不是一个新的领域，考虑解决方案和架构已经有数十年。应用集成的一些用法按惯例包含了重量级的适配器，比如那些与SAP集成的集成方法或JDEdwards OneWorld。Spring Integration不能直接支持这些具体情况。尽管Spring Integration支持大量开箱即用的功能，但它对一些典型的适配器缺少支持，比如SFTP、HTTPS或AS2。目前，一些专有的解决方案能更好地支持这些需求。有些解决方案非常昂贵，所以你可以为Spring Integration试着改造第三方库、编写自己的适配器。如果你有兴趣，你会因为为Spring Integration编写适配器相当简单而感到惊喜。你要想开始创建解决方案，只需要看看jSch[18]、Jakarta Commons VFS[19]或Jakarta Commons Net [20]。

这些单词都可以用来形容人或物体在空中的运动，但它们表示的程度和方式是不同的。下面是它们的具体区别：jump：意为“跳”，通常指用双脚突然离地，再着陆到一个新的位置。例如，“我跳过水沟”（I jumped over the ditch）。skip：意为“连续跳跃”，比起jump，skip的动作更轻快、优美，可以持续多次。例如，“小孩子在操场上跳绳”（The kids are skipping rope on the playground）。hop：意为“单脚跳”，通常指用一只脚离地而另一只脚留在原地，重复使用两只脚完成跳跃动作。例如，“我跳到了水泥块上”（I hopped onto the concrete block）。leap：意为“飞跃”，通常指从一个地方直接跃向另一个很远的地方，通常距离比较远或高度比较大。例如，“猎豹跨越山峰”（The cheetah leaped over the mountain）。spring：意为“弹跳”。通常指向上或向前的一种跳跃动作，通常带有弹性或反弹力。例如，“猴子从树枝上跳了下来”（The monkey sprang from the tree branch）。