绿色记忆 » JacksonJSON https://blog.gmem.cc Fri, 17 Apr 2026 09:20:32 +0000 en-US hourly 1 http://wordpress.org/?v=3.9.14 JacksonJson知识集锦 https://blog.gmem.cc/jacksonjson-faq https://blog.gmem.cc/jacksonjson-faq#comments Sat, 22 Dec 2012 04:42:57 +0000 http://blog.gmem.cc/?p=1237 基础知识 Jackson JSON 提供了一系列API，便于Java程序读写JSON字符串。它具有强大对数据绑定能力，可以方便的在Java对象和JSON字符串之间进行转换。 创建JSON 从Java对象创建（绑定） 代码示例： [crayon-69e29a8710ab3973930852/] 从JsonNode树创建 示例代码： [crayon-69e29a8710ab9228418071/] 构建JSON流 这种方式很不直观，但是节约内存： [crayon-69e29a8710abb692420501/] 解析JSON 解析JSON流 Jackson提供了一种底层API，允许逐符号的处理JSON： [crayon-69e29a8710abe491043479/] 解析为JsonNode树 [crayon-69e29a8710ac0005878873/] 解析为Java对象（绑定）  [crayon-69e29a8710ac3840334729/] [...]

The post JacksonJson知识集锦 appeared first on 绿色记忆.

]]>
基础知识

Jackson JSON 提供了一系列API，便于Java程序读写JSON字符串。它具有强大对数据绑定能力，可以方便的在Java对象和JSON字符串之间进行转换。

创建JSON
从Java对象创建（绑定）

代码示例：

ObjectMapper mapper = new ObjectMapper();
// 启用缩进，更易读
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
// 输出Map类型时，以键排序
mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);
// 日期对象的默认输出格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));

/**
 * Java字段名/属性名到JSON字段的映射策略
 */
mapper.setPropertyNamingStrategy( new PropertyNamingStrategy() {
    public String nameForField( MapperConfig config, AnnotatedField field, String defaultName ) {
        if ( field.getFullName().equals( "cc.gmem.vo.Entity#name" ) )
            return "Entity-Name";
        return super.nameForField( config, field, defaultName );
    }

    public String nameForGetterMethod( MapperConfig config, AnnotatedMethod method, String defaultName ) {
        if ( method.getAnnotated().getDeclaringClass().equals( Entity.class ) && defaultName.equals( "no" ) )
            return "Entity-No";
        return super.nameForGetterMethod( config, method, defaultName );
    }
} );
// 忽略空属性/字段
mapper.setSerializationInclusion(Include.NON_EMPTY);
// 把entity转换为JSON然后写入标准输出
mapper.writeValue(System.out, entity);
从JsonNode树创建

示例代码：

// 此工厂用于创建JsonNode对象
JsonNodeFactory factory = new JsonNodeFactory( false );
// 此工厂用于创建JSON的生成器、解析器
JsonFactory jsonFactory = new JsonFactory();
// 写入到标准输出
JsonGenerator generator = jsonFactory.createGenerator( System.out );
ObjectMapper mapper = new ObjectMapper();
// 根节点
ObjectNode entity = factory.objectNode();
entity.put( "name", "entityname" );
mapper.writeTree( generator, entity );
构建JSON流

这种方式很不直观，但是节约内存：

JsonFactory factory = new JsonFactory();
JsonGenerator generator = factory.createGenerator(new FileWriter(new File("entity.json")));


generator.writeStartObject();
generator.writeFieldName("name");
generator.writeString("Alex");
generator.writeFieldName("dataset");

generator.writeStartArray();
generator.writeStartObject();
generator.writeStringField("zip", "223442");
generator.writeEndObject();
generator.writeEndArray();
generator.writeEndObject();

generator.close();
解析JSON
解析JSON流

Jackson提供了一种底层API，允许逐符号的处理JSON：

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser( "{ addresses: [ { zip: 223442 } ] }" );
// 允许非标准的JSON格式：不带引号的字段名
parser.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true );
while ( !parser.isClosed() ) {
    // 获取下一个解析得到的记号
    JsonToken token = parser.nextToken();
    // 没有下一个记号，说明解析完毕
    if ( token == null ) break;
    // 寻找名为addresses的字段
    if ( JsonToken.FIELD_NAME.equals( token ) && "addresses".equals( parser.getCurrentName() ) ) {
        // 期望下一个符号是数组开始
        token = parser.nextToken();
        if ( !JsonToken.START_ARRAY.equals( token ) ) break;
        // 期望下一个符号是对象开始
        token = parser.nextToken();
        if ( !JsonToken.START_OBJECT.equals( token ) ) break;
        while ( true ) {
            token = parser.nextToken();
            if ( token == null ) break;
            if ( JsonToken.FIELD_NAME.equals( token ) && "zip".equals( parser.getCurrentName() ) ) {
                token = parser.nextToken();
                System.out.println( parser.getText() );
            }

        }

    }

}
解析为JsonNode树
ObjectMapper mapper = new ObjectMapper();
mapper.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true )

JsonNode node = mapper.readTree( "{ addresses: [ { zip: 223442 } ] }" );
Iterator<String> fieldNames = node.fieldNames();
while ( fieldNames.hasNext() ) {
    String fieldName = fieldNames.next();
    System.out.println( fieldName );
    JsonNode el = node.get( fieldName );
    if ( el instanceof ArrayNode ) {
        ArrayNode ael = (ArrayNode) el;
        ael.forEach( n -> {
            System.out.println( n );
        } );
    }
}
解析为Java对象（绑定） 
ObjectMapper mapper = new ObjectMapper();
// 缩进（漂亮输出pretty-printing
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 禁止把日期类型串行化为数字时间戳
mapper.disable( SerializationFeature.WRITE_DATES_AS_TIMESTAMPS );
// 遇到里面没有任何可访问字段/属性的对象时怎么办，禁用后将这种对象串行化为{}
mapper.disable( SerializationFeature.FAIL_ON_EMPTY_BEANS );
// 遇到不可映射的属性时，是否报错
mapper.disable( DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES );
// 允许把空串绑定到null值
mapper.enable( DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT );
// 允许非标准的JSON格式：使用单引号
mapper.configure( JsonParser.Feature.ALLOW_SINGLE_QUOTES, true );
// 允许非标准的JSON格式：不带引号的字段名
mapper.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true );
// 允许JSON中的C/C++风格的注释
mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
// 启用非ASCI字符（默认启用）
mapper.configure( JsonGenerator.Feature.ESCAPE_NON_ASCII, false );

// 绑定为特定类型
Entity entity = mapper.readValue(json, Entity.class);
// 默认自动转换为Map或者List之类集合对象
Map entity = mapper.readValue(json);
类型转换

Jackson有时可以用来进行数据类型的转换，例如：

// 在包装类型和基本类型的集合之间进行转换
List<Integer> sourceList = ...;
int[] ints = mapper.convertValue(sourceList, int[].class);
// 在POJO和Map之间进行转换
Map<String,Object> propertyMap = mapper.convertValue(pojoValue, Map.class);
PojoType pojo = mapper.convertValue(propertyMap, PojoType.class);
// 将Base64转换为字节数组
String base64 = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz";
byte[] binary = mapper.convertValue(base64, byte[].class);
数据绑定

JSON到Java对象的数据绑定，主要依赖于注解

注解列表
注解 说明
@JsonProperty

用于字段/setter/getter上，指定该字段映射到的JSON字段名

属性：
defaultValue  指定默认值，核心绑定模块没有使用该属性
@JsonIgnore 用于字段/setter上，指定该字段不进行数据绑定
@JsonIgnoreType 用于类上，指定哪些类型的字段都被忽略
@JsonAutoDetect 用于类上，指定哪些类型的方法用于属性的自动发现。示例：
@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class PrivateBean {
    private int id;
    private String name;
}
@JsonIgnoreProperties 用于类上，指定哪些字段不进行数据绑定
@JsonInclude 用于类或字段上，指定哪些“无值“（null、空）需要包含在串行化过程中
@JsonFormat 指定如何格式化某个字段，例如：
// 格式化为带毫秒的
@JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ", locale = "zh", timezone = "GMT+8")
// 格式化为数字时间戳
@JsonFormat(shape = JsonFormat.Shape.NUMBER)
private Date date;
@JsonUnwrapped 在串行化时，展开一个嵌入式对象，在反串行化时，包装对应的几个字段为对象
@JsonView 用于定义视图，每个POJO可以定义多个视图，这些视图包含不同的属性
@JsonNaming

用于指定JSON与POJO转换时的名称映射策略：
LOWER_CAMEL_CASE  JSON使用小写开头的驼峰式
KEBAB_CASE  JSON使用短横线连接式，例如kebab-case
SNAKE_CASE  JSON使用下划线连接时，snake_case
UPPER_CAMEL_CASE  JSON使用大写开头的驼峰式，UpperCamelCase

示例：

@JsonNaming( PropertyNamingStrategy.SnakeCaseStrategy.class )
public class FaceRecogResult {} 
反串行化注解
@JacksonInject

指示属性通过注入得到，而不是从JSON解析到

示例：

public class BeanWithInject {
    @JacksonInject
    public int key;
}

// 注入的上下文对象
InjectableValues inject = new InjectableValues.Std()
                .addValue( int.class, 1 ).addValue( "key", "value" );
new ObjectMapper().reader(inject).forType(BeanWithInject.class).readValue(json);
@JsonAnySetter 定义一个具有两个参数的方法为通配的Setter，用于绑定未成功映射的JSON属性
@JsonCreator Jackson JSON不需要默认构造器。在公共/私有的构造器上加上此注解，则Jackson在绑定时自动调用此构造器来创建对象：
@JsonCreator
private CtorBean(@JsonProperty("name") String name, @JsonProperty("age") int age)
{
    this.name = name;
    this.age = age;
}

或者，你也可以注解在静态的工厂方法上：

@JsonCreator
public static FactoryBean create(@JsonProperty("name") String name) {
    // construct and return an instance
} 
@JsonSetter 用于指定任意方法为Setter
@JsonEnumDefaultValue 2.8新增。反串行化未知枚举值时，给出默认值
@JsonDeserialize 指定一个自定义的反串行化器：
public class Event {
    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date eventDate;
}
串行化注解
@JsonAnyGetter 指定一个用作通配Getter的方法，调用该方法应该获得一个Map，其中所有键会作为JSON的额外属性
@JsonGetter 用于指定任意方法为Getter
@JsonPropertyOrder 用于指定属性的串行化顺序
@JsonRawValue

指示一个属性的值应该原样的放置到产生的JSON中，不进行任何转义

在属性值是预先准备好的JSON格式时，使用该注解
@JsonValue 在POJO的某个方法上标注，当此POJO被串行化时，调用此方法得到的值作为串行化结果 
@JsonRootName  给串行化后的POJO加上一个外套：
@JsonRootName(value = "user")
public class UserWithRoot {
    public int id;
    public String name;
}

导致串行化为：

{
    "user": {
        "id": 1,
        "name": "John"
    }
}
@JsonAppend 在串行化时添加额外字段，而不需要改变类。示例：
@JsonAppend(attrs = { 
  @JsonAppend.Attr(value = "version") 
})
public class BeanWithAppend {
    private int id;
    private String name;
}
ObjectWriter writer = mapper.writerFor(BeanWithAppend.class).withAttribute("version", "1.0");
System.out.println( writer.writeValueAsString(bean) );
// 输出如下：
{
    "id": 2,
    "name": "Bean With Append Annotation",
    "version": "1.0"
}
@JsonSerialize 指定一个自定义的串行化器：
public class Event {
    @JsonSerialize(using = CustomDateSerializer.class)
    public Date eventDate;
}
类型处理
@JsonSubTypes

用于类上，指示该类型的子类型，反串行化多态类时如果基于逻辑类型名称，则可以使用

示例一：

@JsonTypeInfo( 
    use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class" 
)
@JsonSubTypes( {
        @JsonSubTypes.Type( value = Lion.class, name = "lion" ),
        @JsonSubTypes.Type( value = Elephant.class, name = "elephant" )
} )
abstract class Animal {}
class Lion extends Animal {}
class Elephant extends Animal {}

 串行化结果为：

// mapper.writeValue( System.out, new Lion() );
{
  "@class" : "cc.gmem.study.jackson.Lion"
}

 示例二：

@JsonTypeInfo( 
    use = JsonTypeInfo.Id.MINIMAL_CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class" 
)
abstract class Animal {}

 串行化结果为：

{
  "@class" : ".Lion"
}

类似的：

@JsonTypeInfo( use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class" )
// 串行化结果：
{
  "@class" : "com.kingsmartsi.pems.fr.stport.vo.Lion"
}

@JsonTypeInfo( use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="@class" )
abstract class Animal {}
// 串行化结果：
{
  "@class" : "Lion"
} 
@JsonTypeId 用于类上，指示该字段的值用作类型标识
@JsonTypeName 用于类上，定义一个逻辑类名。示例：
@JsonTypeInfo( use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="@class" )
abstract class Animal {}
@JsonTypeName("LION")
class Lion extends Animal {}

// 串行化结果：
{
  "@class" : "LION"
}
对象引用和标识符

@JsonManagedReference

@JsonBackReference

这一对注解用于指示、处理父子关系。可以用来处理对象循环引用

示例：

class Hotel {
    // 管理方，负责输出JSON
    @JsonManagedReference
    private List<Room> rooms;
}
class Room {
    // 被管理方，属性被忽略
    @JsonBackReference
    private Hotel hotel;
}

// mapper.writeValue( System.out, hotel );
{
  "rooms" : [ { }, { } ]
} 
@JsonIdentityInfo

类/属性注解，用于指定对象标识符，这样，指向单个POJO的多个引用可以被正确的反串行化。可以用于处理对象循环引用

示例：

@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id"
)
class Hotel {
    private int id;
    private List<Room> rooms;
}
@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id"
)
class Room {
    private int id;
    private Hotel hotel;
}

// 串行化Hotel的结果为：
{
  "id" : 1,
  "rooms" : [ {
    "id" : 100,
    "hotel" : 1
  }, {
    "id" : 101,
    "hotel" : 1
  } ]
} 
常见问题
JacksonJson把JSON绑定为对象出错

报错信息：Unrecognized field "***" (Class ***), not marked as ignorable
报错原因：JSON中包含对象没有的属性
解决办法： 

#方法一
@Entity
@Table ( name = "T_USER" )
@JsonIgnoreProperties ( ignoreUnknown = true )
public class User implements java.io.Serializable

#方法二
ObjectMapper objectMapper = getObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
JacksonJson把对象转换为JSON，导致StackOvewFlowError

报错信息：存在循环引用
解决办法：设置@JsonIgnore。JacksonJson 2.x版本中有专门处理循环引用的注解

The post JacksonJson知识集锦 appeared first on 绿色记忆.

]]> https://blog.gmem.cc/jacksonjson-faq/feed 0 Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 https://blog.gmem.cc/spring-config-with-hibernate-jacksonjson-aspectj https://blog.gmem.cc/spring-config-with-hibernate-jacksonjson-aspectj#comments Mon, 26 Nov 2012 08:39:24 +0000 http://blog.gmem.cc/?p=1110 本文提及的该套配置文件，覆盖了JavaEE项目开发的最常见需求，包括：依赖注入、事务控制、AOP、任务调度、缓存、MVC框架等方面的内容。 容易改变的配置项独立到属性文件中： [crayon-69e29a87113f6622397956/] Spring配置文件部分： [crayon-69e29a87113fa376526827/] Spring MVC配置文件部分： [crayon-69e29a8711400571514889/] ehcache配置部分： [crayon-69e29a8711404096952224/] Web.xml配置（使用了Spring的JavaConfig）： [crayon-69e29a8711407127867423/] Java Config类： [crayon-69e29a871140a872502621/] [crayon-69e29a871140c383166483/] Maven依赖包列表： [crayon-69e29a871140e195136539/] Maven插件配置（支持AspectJ）： [crayon-69e29a8711412023138659/]

The post Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 appeared first on 绿色记忆.

]]> 本文提及的该套配置文件，覆盖了JavaEE项目开发的最常见需求，包括：依赖注入、事务控制、AOP、任务调度、缓存、MVC框架等方面的内容。
容易改变的配置项独立到属性文件中：
hibernateDialect=org.hibernate.dialect.MySQL5Dialect
#启用了log4jdbc支持
jdbcDriver=net.sf.log4jdbc.DriverSpy
jdbcDriverUrl=jdbc:log4jdbc:mysql://192.168.0.201:3306/initpemsdb1.1.1
jdbcUserName=root
jdbcPassword=root

Spring配置文件部分：
<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:task="http://www.springframework.org/schema/task" 
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.0.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
    ">
    <!-- 定义属性，在后面的配置中可以使用#{appCfg.xxx}引用 -->
    <util:properties id="appCfg" location="classpath:applicationConfig.properties" />
    <!-- 包扫描配置 -->
    <context:component-scan base-package="cc.gmem.demo">
        <!-- 去除Java Config类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
        <!-- 去除Spring MVC类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        <!-- 匹配AspectJ Pattern的类被去除 -->
        <context:exclude-filter type="aspectj" expression="cc.gmem.demo.aop.web.*" />
    </context:component-scan>
    <!-- 启用注解支持 -->
    <context:annotation-config />
    <!-- 支持@Configurable注解 -->
    <context:spring-configured />
    <!--  启用注解方式的事务：基于AspectJ织入 -->
    <tx:annotation-driven transaction-manager="txManager" mode="aspectj" />
    <!--  启用注解方式的缓存配置：基于AspectJ织入 -->
    <cache:annotation-driven cache-manager="cacheManager" mode="aspectj" />
    <!--  启用注解方式的任务执行(例如@Async)：基于AspectJ织入 -->
    <task:annotation-driven executor="taskExecutor" mode="aspectj" />
    
    <!--  任务调度器配置，pool-size为线程池大小，限制了同时最多被调度的任务 -->
    <task:scheduler pool-size="100" id="scheduler" />
    <!-- 任务计划列表，支持固定频率、固定延迟、Cron表达式等 -->
    <task:scheduled-tasks scheduler="scheduler">
        <task:scheduled fixed-rate="120000" method="run" ref="hibernateStatisticsMonitor" />
    </task:scheduled-tasks>
    <!-- 任务执行器，用于异步执行任务 -->
    <task:executor id="taskExecutor" keep-alive="3600" pool-size="10-100" queue-capacity="10000" rejection-policy="CALLER_RUNS" />
    <!-- 引入其它Spring配置文件 -->
    <import resource="report-and-etl.xml" />  
    <!-- Hibernate配置  -->
    <bean id="dataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
        <property name="alias" value="connectionPool" />
        <property name="driver" value="#{appCfg.jdbcDriver}" />
        <property name="driverUrl" value="#{appCfg.jdbcDriverUrl}" />
        <property name="user" value="#{appCfg.jdbcUserName}" />
        <property name="password" value="#{appCfg.jdbcPassword}" />
        <property name="statistics" value="10s" />
        <property name="minimumConnectionCount" value="10" />
        <property name="maximumConnectionCount" value="100" />
        <property name="simultaneousBuildThrottle" value="10" />
        <property name="maximumActiveTime" value="3600000" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" autowire="byName" />
    <bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" lazy-init="true" />
    <bean id="sessionFactory" p:dataSource-ref="dataSource" class="cc.gmem.demo.hibernate.AnnotationSessionFactoryBean" depends-on="appCfg" >
        <property name="packagesToScan">
            <list>
                <value>cc.gmem.demo.**.domain</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=#{appCfg.hibernateDialect}
                hibernate.jdbc.batch_size=30
                hibernate.show_sql=false
                hibernate.format_sql=true
                hibernate.generate_statistics=true
                hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
                hibernate.current_session_context_class=org.springframework.orm.hibernate3.SpringSessionContext
                hibernate.query.factory_class=org.hibernate.hql.ast.ASTQueryTranslatorFactory
                hibernate.hbm2ddl.auto=update
                #启用二级缓存
                hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=true
                hibernate.cache.region.factory_class=org.hibernate.cache.SingletonEhCacheRegionFactory
            </value>
        </property>
    </bean>
    <!-- Spring缓存配置 -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
        <property name="cacheManager" ref="ehcache" />
    </bean>
    <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        <property name="configLocation">
            <value>classpath:ehcache.xml</value>
        </property>
        <property name="shared" value="true" />
    </bean>
    <bean id="hibernateStatisticsMonitor" class="cc.gmem.demo.hibernate.HibernateStatisticsMonitor" />
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" p:sessionFactory-ref="sessionFactory" />
    <!-- Velocity引擎配置 -->
    <bean id="velocityEngine" class="org.apache.velocity.app.VelocityEngine">
        <constructor-arg type="java.util.Properties">
            <value>
                <![CDATA[
                #{T(org.apache.velocity.runtime.RuntimeConstants).RUNTIME_LOG_LOGSYSTEM_CLASS}=org.apache.velocity.runtime.log.Log4JLogChute
                runtime.log.logsystem.log4j.logger=velocityLogger
                #{T(org.apache.velocity.runtime.RuntimeConstants).INPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).OUTPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).VM_PERM_ALLOW_INLINE}=true
                #{T(org.apache.velocity.runtime.RuntimeConstants).RESOURCE_LOADER}=class
                #{T(org.apache.velocity.runtime.RuntimeConstants).PARSER_POOL_SIZE}=100
                class.resource.loader.class=org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
                ]]>
            </value>
        </constructor-arg>
    </bean>
    <!--国际化支持-->
    <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
         <property name="basenames">
             <list>
                 <value>classpath:message.gmemdemo</value>
             </list>
         </property>
         <property name="defaultEncoding" value="UTF-8" />
         <property name="cacheSeconds" value="5" />
    </bean>
    <!--Jackson JSON -->
    <bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper" autowire="byType" />
    <!-- Spring类型转换服务，特别是用于时间日期格式转换 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="net.greenmemory.spring.converter.DateTimeConvertor">
                    <constructor-arg>
                        <array>
                            <value>yyyy-MM-dd</value>
                            <value>yyyy-MM-dd HH:mm:ss</value>
                            <value>yyyy-MM-dd HH:mm:ss.SSS</value>
                       </array>
                    </constructor-arg>
                </bean>
            </set>
       </property>
       <property name="formatters">
           <set>
               <bean class="org.springframework.format.datetime.DateFormatter">
                   <constructor-arg>
                       <value>yyyy-MM-dd</value>
                   </constructor-arg>
               </bean>
           </set>
       </property>
       <property name="formatterRegistrars">
           <set>
           </set>
       </property>
    </bean>
</beans>

Spring MVC配置文件部分：
<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    ">
    <context:component-scan base-package="cc.gmem.demo.**.ctrl">
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
    </context:component-scan>
    <context:component-scan base-package="cc.gmem.demo.aop.web" />

    <context:annotation-config />

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.jacksonjson.MappingJackson2HttpMessageConverter">
                <property name="objectMapper" ref="objectMapper" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <mvc:interceptors>
        <bean id="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>
            <mvc:interceptor>     
            <mvc:mapping path="/home/*" /> 
            <!-- 自定义MVC拦截器 -->
            <bean class="cc.gmem.demo.spring.LogonInterceptor" /> 
        </mvc:interceptor>  
        
    </mvc:interceptors>

    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
        <property name="order" value="0" />
    </bean>

    <mvc:resources mapping="/css/**" location="/css/" />
    <mvc:resources mapping="/icons/**" location="/icons/" />
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/themes/**" location="/themes/" />
    <mvc:resources mapping="/js/**" location="/js/" />
</beans>

ehcache配置部分：
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="D:/Temp/ehcache" />
    <defaultCache eternal="false" />
    <cache name="entityCache" eternal="false" maxElementsInMemory="1000" timeToIdleSeconds="120" timeToLiveSeconds="3600"
        overflowToDisk="true" memoryStoreEvictionPolicy="LFU" />
</ehcache>

Web.xml配置（使用了Spring的JavaConfig）：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cc.gmem.demo.spring.SpringBeanDefinitionRegistrar</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>cc.gmem.demo.spring.SpringMVCBeanDefinitionRegistrar</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>adminServlet</servlet-name>
        <url-pattern>/proxool</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>

    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/jsp/error-404.jsp</location>
    </error-page>
    <error-page>
        <error-code>401</error-code>
        <location>/WEB-INF/jsp/error-401.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/WEB-INF/jsp/error-500.jsp</location>
    </error-page>
     <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Java Config类：
@Configuration
/* XML-based bean definitions */
@ImportResource ( "classpath:applicationContext.xml" )
public class SpringBeanDefinitionRegistrar
{

    /* Auto injected spring context */
    @SuppressWarnings ( "unused" )
    @Inject
    private ApplicationContext applicationContext;

    /* Programmatic bean definition */
    @Bean ( name = "helper" )
    public Helper helper()
    {
        Helper helper = new Helper();
        return helper;
    }

}

@Configuration
@ImportResource ( "classpath:spring-mvc.xml" )
public class SpringMVCBeanDefinitionRegistrar
{

}

Maven依赖包列表：
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>3.1.2.RELEASE</spring.version>
    <hibernate.version>3.6.10.Mod</hibernate.version>
    <aspectj.version>1.6.11</aspectj.version>
    <jackson.version>2.0.4</jackson.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.4</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>el-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>proxool</groupId>
        <artifactId>proxool</artifactId>
        <version>0.9.1</version>
    </dependency>

    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.15.0-GA</version>
    </dependency>

    <dependency>
        <groupId>net.sf.log4jdbc</groupId>
        <artifactId>log4jdbc3</artifactId>
        <version>1.2-ext-3</version>
    </dependency>
    <dependency>
        <groupId>com.sqlinform</groupId>
        <artifactId>sqlinform</artifactId>
        <version>0.0.1</version>
    </dependency>

    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>jsr250-api</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>

    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.1</version>
    </dependency>

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.9</version>
    </dependency>
    
    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>quartz-all</artifactId>
        <version>1.6.3</version>
    </dependency>
</dependencies>

Maven插件配置（支持AspectJ）：
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.4</version>
    <executions>
        <execution>
            <id>compile</id>
            <configuration>
                <XnoInline>true</XnoInline>
                <forceAjcCompile>true</forceAjcCompile>
                <showWeaveInfo>true</showWeaveInfo>
                <source>1.5</source>
                <target>1.5</target>
                <encoding>UTF-8</encoding>
                <verbose>true</verbose>
                <outxml>true</outxml>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

The post Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 appeared first on 绿色记忆.

]]> https://blog.gmem.cc/spring-config-with-hibernate-jacksonjson-aspectj/feed 0