`

Spring ApplicationContext.xml配置的12个技巧和Bean属性说明

阅读更多

Spring ApplicationContext.xml配置的12个技巧

 Spring是一个强有力的java程序框架,其被广泛应用于java的程序中。它用POJO提供了企业级服务。 Spring利用依赖注入可以获得简单而有效的测试能力。Spring beans,依赖关系,以及服务所需要的bean都将在配置文件中予以描述,配置文件一般采用XML格式。然而XML配置文件冗长而不易使用,在你进行一 个使用了大量bean的大项目中它将变得难以阅读和控制。
 
在这篇文章中我将给你展示12种的有关Spring XML配置文件的最佳技巧。它们中的一些具有更多的实际意义,而不仅是最好的技巧。请注意另外一些因素,例如域模型的设计,会影响到XML配置,但是这篇文章更关注于XML配置的可读性和可操控性。
 
1.避免使用自动装配
Spring 可以通过bean类的自省来实现自动装配依赖,这样的话你就不必明确地描述bean的属性或者构造函数的参数。根据属性名称活匹配类型,bean属性可以 自动进行装配。而构造函数可以根据匹配类型自动装配。你甚至可以设置自动装配进行自动侦测,这样Spring替你就会选择一个合适的机制。请看下面的例 子:
 
 
Spring 可以通过bean类的自省来实现自动装配依赖,这样的话你就不必明确地描述bean的属性或者构造函数的参数。根据属性名称活匹配类型,bean属性可以 自动进行装配。而构造函数可以根据匹配类型自动装配。你甚至可以设置自动装配进行自动侦测,这样Spring替你就会选择一个合适的机制。请看下面的例 子:
 
    <bean id="orderService"
        class="com.lizjason.spring.OrderService"
        autowire="byName"/>
 
OrderService 类的属性名被用来和容器中的一个bean实例进行匹配。自动装配会默默的保存一些类型信息并降低混乱。然而,由于它会牺牲掉这种配置的直观性和可维护性, 你在实际的项目中将不会用到它。许多指南和陈述材料都把它吹捧为Spring的一个非常cool的特性,而没有提到它的这个缺点。依我之见,就像 Spring的对象池一样,它更多了一些商业味道。它看起来好像可以使XML配置文件更精简一些,但实际上却增加其复杂性,尤其是在你的较大规模的工程中 已经定义了很多bean的时候更是如此。Spring允许你混合使用自动和手动装配,但是这种矛盾会使XML配置更加的令人费解。
 
2.使用命名规范
和Java 编码的理念一样,在项目中始终用清晰的,描述性的,一致的命名规范对开发人员理解XML配置非常有用。拿bean ID举例来说,你可以遵循Java类中属性的命名规范。比如说,OrderServiceDAO的bean ID应该是orderServiceDAO。对于大项目来说,在bean ID前加包名来作为前缀。
 
3.使用简化格式
简化格式有利于减少冗余,因为它把属性值和引用作为属性,而不是子元素。看下面的例子:
    <bean id="orderService"
        class="com.lizjason.spring.OrderService">
        <property name="companyName">
            <value>lizjason</value>
        </property>
        <constructor-arg>
            <ref bean="orderDAO">
        </constructor-arg>
    </bean>
以上程序可以重新以简化格式书写为:
    <bean id="orderService"
        class="com.lizjason.spring.OrderService">
        <property name="companyName"
            value="lizjason"/>
        <constructor-arg ref="orderDAO"/>
    </bean>
简化格式在1.2版本时已经可用了,但请注意不存在<ref local="...">这种简化格式不仅可以较少你的代码输入量,而且可以使XML配置更加的清晰。当你的配置文件中存在大量的bean定义时,它可以显著地提高可读性。
 
4.尽量使用type而不是index去解决构造函数参数的匹配问题
当构造函数中有多个同类型的参数时,Spring只允许你使用从0开始的index或者value标签来解决这个问题。请看下面的例子:
    <bean id="billingService"
        class="com.lizjason.spring.BillingService">
        <constructor-arg index="0" value="lizjason"/>
        <constructor-arg index="1" value="100"/>
    </bean>
最好用type属性取代上面的做法:
    <bean id="billingService"
        class="com.lizjason.spring.BillingService">
        <constructor-arg type="java.lang.String"
            value="lizjason"/>
        <constructor-arg type="int" value="100"/>
    </bean>
 
用index可以稍微减少冗余,但是它更容易出错且不如type属性可读性高。你应该仅在构造函数中有参数冲突时使用index。
 
5.如可能,尽量复用bean定义
Spring 提供了一种类似于继承的机制来降低配置信息的重复并使XML配置更加的简单。一个子bean可以从它的父bean继承配置信息,本质上这个父bean就像 它的子bean的一个模板。这是一个在大型项目中必须使用的特性。所有你要做的就是把父bean的abstract属性置为true,并在子bean中加 以引用。例如:
    <bean id="abstractService" abstract="true"
        class="com.lizjason.spring.AbstractService">
        <property name="companyName"
            value="lizjason"/>
    </bean>
 
    <bean id="shippingService"
        parent="abstractService"
        class="com.lizjason.spring.ShippingService">
        <property name="shippedBy" value="lizjason"/>
    </bean>
shippingService bean继承了abstractService bean的属性companyName的值lizjason。注意,如果你为bean声名一个class或工厂方法,这个bean将会默认为abstract
 
6.尽量使用ApplicationContext装配bean,而不是用import
像Ant脚本中imports一样,Spring的import 元素对于模块化bean的装配非常有用,例如:
    <beans>
        <import resource="billingServices.xml"/>
        <import resource="shippingServices.xml"/>
        <bean id="orderService"
            class="com.lizjason.spring.OrderService"/>
    <beans>
然而,比起在XML中用imports预装配这些bean,利用ApplicationContext来配置它们将更加灵活,也可以使XML配置更加的易于管理。你可以像下面这样传递一个bean定义数组到ApplicationContext的构造函数中:
    String[] serviceResources =
        {"orderServices.xml",
        "billingServices.xml",
        "shippingServices.xml"};
ApplicationContext orderServiceContext = new
ClassPathXmlApplicationContext(serviceResources);
 
7.id来标识bean
你可以用id 或名字作为bean的标识。用id可读性较差,但是它可以影响XML分析器使bean的reference有效。如果id由于XML IDREF约束而无法使用,你可以用name作为bean的标识。XML IDREF约束是指id必须以字母开始(或者是在XML声名了的一个标点符号),后面可以是字母,数字,连字符,下划线,冒号或full stops(不知道怎么翻译好)。在实际应用中很少会遇到XML IDREF约束问题。
 
8.在开发阶段使用依赖检查
你可以为bean的dependency-check属性设置一个值来取代默认的none,比如说simple,objects或者all,这样的话容器将替你做依赖有效性的检查。当一个bean的所有属性(或者某些属性目录)都被明确设置,或利用自动装配时将会非常有用。
    <bean id="orderService"
        class="com.lizjason.spring.OrderService"
        dependency-check="objects">
        <property name="companyName"
            value="lizjason"/>
        <constructor-arg ref="orderDAO"/>
    </bean>
在这个例子中,容器将确保这些属性不是privitives或者保证collections是为orderService bean设置的。为所有的bean设置默认的依赖检查是可能的,但这个特性由于有些bean的属性不需要设置而很少使用。
 
9.为每个配置文件加一个描述注释
XML配置文件中最好使用有描述性的id和name,而不是成堆的注释。另外,加一个文件描述头将会非常有用,这个描述可以概括文件中定义的bean。另一个选择,你可以在description元素中加入描述信息。例如:
    <beans>
        <description>
            This file defines billing service
            related beans and it depends on
            baseServices.xml,which provides
            service bean templates...
        </description>
        ...
    </beans>
description素的一个好处就是工具可以很容易的把描述信息从这个元素中提取出来。
 
10.   和team members沟通变更
当你修改java源码后,要确保更改了配置文件中的相应部分并把这个情况告知你的team members。XML配置文件也是代码,它们是程序的重要组成部分,但它们很难阅读和维护。大多数时间里,你需要同时看XML配置文件和java代码才能知道是怎么回事。
 
11.   setter注入和构造函数注入,优先使用前者
Spring提供了三种注入方式:构造函数注入,setter注入和方法注入。一般我们使用前两种。
    <bean id="orderService"
        class="com.lizjason.spring.OrderService">
        <constructor-arg ref="orderDAO"/>
    </bean>
 
    <bean id="billingService"
        class="com.lizjason.spring.BillingService">
        <property name="billingDAO"
            ref="billingDAO">
    </bean>
在这个例子中,orderService bean用了构造函数注入,而BillingService bean用了setter注入。构造函数注入可以确保bean正确地构建,但是setter注入更加的灵活和易于控制,特别是当class有多个属性并且它们中的一些是可选的情况是更是如此。
 
12.   不要滥用注入
就像前面提到的,Spring的ApplicationContextEclipse and IntelliJjava代码更加的易于阅读,维护和管理比使XML文件可以替你创建java对象但不是所有的java对象都应该通过注入创建。例如域对象就不应该通过ApplicationContext创建。Spring是一个优秀的框架,但是考虑到可读性和可操控性,基于XML配置的配置会在定义很多bean的时候出现麻烦。过渡使用依赖注入将会使XML配置更加的复杂和冗长。切记,当使用高效的IDE时,例如
 
结论
XML是Spring 流行的配置格式。存在大量bean定义时,基于XML的配置会变得冗长而不易使用。Spring提供了丰富的配置选项。适当地使用这些选项可以使XML配 置更加的清晰,但其它的一些选项,例如自动装配,可能会降低可读性和可维护性。参考本文中提到的这些技巧可能会帮助你创建干净而易读的XML配置文件



<bean

id="beanId"(1)

name="beanName"(2)

class="beanClass"(3)

parent="parentBean"(4)

abstract="true | false"(5)

singleton="true | false"(6)

lazy-init="true | false | default"(7)

autowire="no | byName | byType | constructor | autodetect | default"(8)

dependency-check = "none | objects | simple | all | default"(9)

depends-on="dependsOnBean"(10)

init-method="method"(11)

destroy-method="method"(12)

factory-method="method"(13)

factory-bean="bean">(14)

</bean>


(1)、id: Bean的唯一标识名。它必须是合法的XML ID,在整个XML文档中唯一。

(2)、name: 用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。

(3)、class: 用来定义类的全限定名(包名+类名)。只有子类Bean不用定义该属性。

(4)、parent: 子类Bean定义它所引用它的父类Bean。这时前面的class属性失效。子类Bean会继承父类Bean的所有属性,子类Bean也可以覆盖父类Bean的属性。注意:子类Bean和父类Bean是同一个Java类。

(5)、abstract(默认为”false”):用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化,一般用于父类Bean,因为父类Bean主要是供子类Bean继承使用。

(6)、singleton(默认为“true”):定义Bean是否是Singleton(单例)。如果设为“true”,则在BeanFactory作用范围内,只维护此Bean的一个实例。如果设为“flase”,Bean将是Prototype(原型)状态,BeanFactory将为每次Bean请求创建一个新的Bean实例。

(7)、lazy-init(默认为“default”):用来定义这个Bean是否实现懒初始化。如果为“true”,它将在BeanFactory启动时初始化所有的Singleton Bean。反之,如果为“false”,它只在Bean请求时才开始创建Singleton Bean。

(8)、autowire(自动装配,默认为“default”):它定义了Bean的自动装载方式。

1、“no”:不使用自动装配功能。

2、“byName”:通过Bean的属性名实现自动装配。

3、“byType”:通过Bean的类型实现自动装配。

4、“constructor”:类似于byType,但它是用于构造函数的参数的自动组装。

5、“autodetect”:通过Bean类的反省机制(introspection)决定是使用“constructor”还是使用“byType”。

(9)、dependency-check(依赖检查,默认为“default”):它用来确保Bean组件通过JavaBean描述的所以依赖关系都得到满足。在与自动装配功能一起使用时,它特别有用。

1、 none:不进行依赖检查。

2、 objects:只做对象间依赖的检查。

3、 simple:只做原始类型和String类型依赖的检查

4、 all:对所有类型的依赖进行检查。它包括了前面的objects和simple。

(10)、depends-on(依赖对象):这个Bean在初始化时依赖的对象,这个对象会在这个Bean初始化之前创建。

(11)、init-method:用来定义Bean的初始化方法,它会在Bean组装之后调用。它必须是一个无参数的方法。

(12)、destroy-method:用来定义Bean的销毁方法,它在BeanFactory关闭时调用。同样,它也必须是一个无参数的方法。它只能应用于singleton Bean。

(13)、factory-method:定义创建该Bean对象的工厂方法。它用于下面的“factory-bean”,表示这个Bean是通过工厂方法创建。此时,“class”属性失效。

(14)、factory-bean:定义创建该Bean对象的工厂类。如果使用了“factory-bean”则“class”属性失效。

 

 

 

下面列出<ref>元素的所有可用的指定方式:

bean:可以在当前文件中查找依赖对象,也可以在应用上下文(ApplicationContext)中查找其它配置文件的对象。

local:只在当前文件中查找依赖对象。这个属性是一个XML IDREF,所以它指定的对象必须存在,否则它的验证检查会报错。

external:在其它文件中查找依赖对象,而不在当前文件中查找。

总的来说,<ref bean="..."/>和<ref local="..."/>大部分的时候可以通用。“bean”是最灵活的方式,它允许你在多个文件之间共享Bean。而“local”则提供了便利的XML验证。


如何使用spring的作用域:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="singleton"/>
这里的scope就是用来配置spring bean的作用域,它标识bean的作用域。
spring2.0之前bean只有2种作用域即:singleton(单例)、non-singleton(也称 prototype), Spring2.0以后,增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此,默认情况下Spring2.0现在有五种类型的Bean。当然,Spring2.0对 Bean的类型的设计进行了重构,并设计出灵活的Bean类型支持,理论上可以有无数多种类型的Bean,用户可以根据自己的需要,增加新的Bean类 型,满足实际应用需求。
1、singleton作用域
当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。换言之,当把 一个bean定义设置为singleton作用域时,Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存(singleton cache)中,并且所有针对该bean的后续请求和引用都 将返回被缓存的对象实例,这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的,单例设计模式表示一个ClassLoader中 只有一个class存在,而这里的singleton则表示一个容器对应一个bean,也就是说当一个bean被标识为singleton时 候,spring的IOC容器中只会存在一个该bean。
配置实例:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="singleton"/>
或者
<bean id="role" class="spring.chapter2.maryGame.Role" singleton="true"/>
2、prototype
prototype作用域部署的bean,每一次请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)都会产生一个新的bean实例,相当与一个new的操作,对于prototype作用域的bean,有一点非常重要,那就是Spring不能对一个prototype bean的整个生命周期负责,容器在初始化、配置、装饰或者是装配完一个prototype实例后,将它交给客户端,随后就对该prototype实例不闻不问了。不管何种作用域,容器都会调用所有对象的初始化生命周期回调方法,而对prototype而言,任何配置好的析构生命周期回调方法都将不会被调用。 清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责。(让Spring容器释放被singleton作用域bean占用资源的一种可行方式是,通过使用 bean的后置处理器,该处理器持有要被清除的bean的引用。)
配置实例:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="prototype"/>
或者
<beanid="role" class="spring.chapter2.maryGame.Role" singleton="false"/>
3、request
request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效,配置实例:
request、session、global session使用的时候首先要在初始化web的web.xml中做如下配置:
如果你使用的是Servlet 2.4及以上的web容器,那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可:
 <web-app>
   ...
  
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
  
</listener>
   ...
</web-app>

,如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现:
<web-app>
 ..
 
<filter> 
    
<filter-name>requestContextFilter</filter-name> 
    
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
 
</filter> 
 
<filter-mapping> 
    
<filter-name>requestContextFilter</filter-name> 
    
<url-pattern>/*</url-pattern>
 
</filter-mapping>
   ...
</web-app>

接着既可以配置bean的作用域了:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="request"/>
4、session
session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效,配置实例:
配置实例:
和request配置实例的前提一样,配置好web启动文件就可以如下配置:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="session"/>
5、global session
global session作用域类似于标准的HTTP Session作用域,不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念,它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean,那么web会自动当成session类型来使用。
配置实例:
和request配置实例的前提一样,配置好web启动文件就可以如下配置:
<bean id="role" class="spring.chapter2.maryGame.Role" scope="global session"/>
6、自定义bean装配作用域
在spring2.0中作用域是可以任意扩展的,你可以自定义作用域,甚至你也可以重新定义已有的作用域(但是你不能覆盖singleton和 prototype),spring的作用域由接口org.springframework.beans.factory.config.Scope来定 义,自定义自己的作用域只要实现该接口即可,下面给个实例:
我们建立一个线程的scope,该scope在表示一个线程中有效,代码如下:
publicclass MyScope implements Scope 
      privatefinal ThreadLocal threadScope 
= new ThreadLocal() {
          
protected Object initialValue() {
             returnnew HashMap(); 
           }
 
     }

     
public Object get(String name, ObjectFactory objectFactory) 
         Map scope 
= (Map) threadScope.get(); 
         Object object 
= scope.get(name); 
        
if(object==null
           object 
= objectFactory.getObject(); 
           scope.put(name, object); 
         }
 
        
return object; 
      }
 
     
public Object remove(String name) 
         Map scope 
= (Map) threadScope.get(); 
        
return scope.remove(name); 
      }

      publicvoid registerDestructionCallback(String name, Runnable callback) 

      }
colo
分享到:
评论

相关推荐

    applicationContext.xml 详细配置

    在 ApplicationContext.xml 文件中,可以定义多个 Bean,例如数据源、Session 工厂、Hibernate 配置等。这些 Bean 将被 Spring 框架自动装配和管理。例如,以下代码定义了一个数据源 Bean: ``` &lt;bean id=...

    Spring ApplicationContext.xml配置的12个技巧演示教学.pdf

    "Spring ApplicationContext.xml配置的12个技巧演示教学" Spring ApplicationContext.xml配置是 Spring 框架中非常重要的一部分,它提供了企业级服务,并且可以通过依赖注入来获得简单而有效的测试能力。然而,在...

    applicationContext.xml详解

    ApplicationContext.xml文件是Spring应用程序中的核心配置文件,它用于定义和配置各种Bean,并管理Bean之间的依赖关系。通过配置ApplicationContext.xml文件,我们可以轻松地实现Spring应用程序的开发和维护。

    Spring 2.5-applicationContext.xml提示信息的配置

    在Spring框架中,`applicationContext.xml`是应用上下文的核心配置文件,用于定义bean的创建、依赖关系以及各种服务的配置。这篇博文“Spring 2.5 - applicationContext.xml提示信息的配置”主要探讨了如何在Spring ...

    详解spring applicationContext.xml 配置文件

    在Spring框架中,`applicationContext.xml`是核心的配置文件,它定义了应用上下文,即Spring容器,用来管理所有bean的创建、初始化、依赖注入以及生命周期。这个文件使用XML语法,遵循特定的命名空间和schema,以...

    struts.xml和applicationContext.xml、web.xml的配置

    在Java Web开发中,`struts.xml`, `applicationContext.xml` 和 `web.xml` 是三个至关重要的配置文件,它们各自负责不同的职责,并协同工作来构建一个完整的应用框架。以下是关于这三个配置文件的详细说明。 首先,...

    spring applicationContext.xml详细配置

    在Spring框架中,`applicationContext.xml`是核心配置文件,用于定义bean的声明、依赖注入、数据源配置、事务管理等。在这个配置文件中,我们可以深入理解Spring如何管理和协调应用程序的各个组件。以下是对`...

    spring3.0 + Quartz1.52 + applicationContext.xml

    2. **配置Scheduler**:在`applicationContext.xml`中,我们需要创建一个`SchedulerFactoryBean`,这是Spring对Quartz Scheduler的封装,它负责初始化和管理Scheduler实例。例如: ```xml &lt;bean id="scheduler" ...

    applicationContext.xml等文件.rar

    在IT行业中,尤其是在Java Web开发领域,`applicationContext.xml`、`db.properties`、`log4j.properties`以及`spring-mvc.xml`等文件是非常关键的配置文件,它们各自负责不同的功能,对于一个完整的应用程序来说不...

    ApplicationContext.xml

    总结起来,`ApplicationContext.xml`是Spring应用的核心,它定义了Bean的生命周期、属性、依赖关系和AOP策略,是理解和使用Spring框架的关键。理解并熟练掌握`ApplicationContext.xml`的配置,对于提升Java开发效率...

    SSH框架applicationContext.xml头部文件

    `applicationContext.xml`是Spring框架的核心配置文件之一,通过合理的配置可以极大地简化开发工作,提高代码的可维护性和扩展性。对于SSH框架而言,`applicationContext.xml`不仅是Spring容器的基础配置文件,也是...

    Spring Boot技术知识点:如何读取不同路径里的applicationContext.xml配置文件2

    此外,`@Component`注解使这个类成为了一个Spring Bean,`ApplicationContextAware`接口则允许我们获取并设置`ApplicationContext`,从而能够在`loadXmlConfigurations`方法中加载XML配置。 在实际开发中,你还需要...

    applicationContext.xml用法

    其中,`applicationContext.xml`是Spring框架的核心配置文件之一,它用于管理应用上下文中的各种Bean以及它们之间的依赖关系。本文将详细介绍`applicationContext.xml`文件的结构、各个元素的作用以及如何正确配置。...

    Spring Boot技术知识点:如何读取不同路径里的applicationContext.xml配置文件5

    - 如果有多个环境的XML配置,可以使用`spring.config.name`属性指定配置文件名(不包括扩展名),然后在指定的`spring.config.location`目录下按环境分文件。例如,开发环境的配置文件可以命名为`application-dev....

    Spring Boot技术知识点:如何读取不同路径里的applicationContext.xml配置文件1

    由于Spring Boot的自动配置特性,当你在XML配置中声明一个bean时,需要小心不要与Spring Boot的自动配置产生冲突。如果需要禁用某个自动配置,可以使用`@EnableAutoConfiguration(exclude = {SomeAutoConfiguration...

    Spring Boot技术知识点:如何读取不同路径里的applicationContext.xml配置文件3

    本篇文章将深入探讨在Spring Boot中如何读取不同路径下的`applicationContext.xml`配置文件。 首先,理解Spring Boot的启动流程至关重要。Spring Boot通过`SpringApplication`类来启动,它会默认寻找`src/main/...

    ssm框架基础配置文件web.xml模板springmvc.xml模板applicationContext.xml模板拿来即用

    3. **applicationContext.xml**:这是Spring的上下文配置文件,主要管理服务层(Service)和数据访问层(DAO)的Bean。包括Bean的定义、依赖注入(DI)、事务管理、AOP(面向切面编程)等配置。 - Bean定义:使用`...

    Spring[applicationContext.xml]灵活性代理

    在Spring框架中,`applicationContext.xml`是应用上下文配置文件,它是Spring IoC(Inversion of Control,控制反转)容器的核心,负责管理和装配应用程序的组件。灵活性代理是指Spring通过AOP(Aspect-Oriented ...

Global site tag (gtag.js) - Google Analytics