paulwong

#

JAX-RS资源

JAX-RS是JAVA EE的一个标准,用来处理RESTFUL的WEBSERVICE。


Jersey 2.4.1 User Guide
https://jersey.java.net/documentation/latest/index.html


The Java EE 6 Tutorial
http://docs.oracle.com/javaee/6/tutorial/doc/gkoib.html


基于JAXB注释的JSON与JAVA BEAN的互转
http://wiki.fasterxml.com/JacksonDataBinding
http://stackoverflow.com/questions/10699038/generating-more-json-like-json-from-jaxb-and-jersey
http://wiki.fasterxml.com/JacksonJAXBAnnotations


例子:
https://github.com/jersey/jersey/tree/2.4.1/examples






posted @ 2013-11-27 12:03 paulwong 阅读(550) | 评论 (0)编辑 收藏

微信公众平台开发资源

【微信公众平台改版后】Java模拟登录微信平台,主动推送消息给用户
http://50vip.com/blog.php?i=349


微信公众账号开发
http://my.oschina.net/ywooer/blog?catalog=419479

posted @ 2013-11-25 22:00 paulwong 阅读(557) | 评论 (0)编辑 收藏

NGINX资源

Nginx + Memcached + Tomcat 集群
http://www.oschina.net/question/1014681_107718


安装NGINX:
https://www.server-world.info/en/note?os=CentOS_Stream_8&p=nginx&f=1

自己生成证书:
https://www.server-world.info/en/note?os=CentOS_Stream_8&p=ssl&f=1

NGINX配置HTTPS:
https://www.server-world.info/en/note?os=CentOS_Stream_8&p=nginx&f=3

NGINX配置负载均衡
https://www.server-world.info/en/note?os=CentOS_Stream_8&p=nginx&f=9

NGINX配置反射代理
https://www.server-world.info/en/note?os=CentOS_Stream_8&p=nginx&f=8



彻底搞懂 Nginx 五大应用场景!出去吹牛逼再也不担心了
https://segmentfault.com/a/1190000040420111

Nginx系列教程(3)nginx缓存服务器上的静态文件
https://segmentfault.com/a/1190000022548261

Nginx常用反向代理配置规则
https://segmentfault.com/a/1190000022501310

Nginx系列教程(10)基于Nginx解决前端访问后端服务跨域问题(Session和cookie无效)
https://segmentfault.com/a/1190000022505420

生产环境之Nginx高可用方案(keepalived+双机热备)
https://segmentfault.com/a/1190000022511710

【nginx】配置Nginx实现负载均衡
https://segmentfault.com/a/1190000017096671

面试官:Nginx 如何实现高并发?常见的优化手段有哪些?
https://segmentfault.com/a/1190000040559345

posted @ 2013-11-24 21:11 paulwong 阅读(270) | 评论 (0)编辑 收藏

基于springMVC+springSecurity3.x+Mybaits3.x的权限系统

https://github.com/lanyuancom/lanyuan @import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

posted @ 2013-11-24 20:54 paulwong 阅读(879) | 评论 (0)编辑 收藏

JAX-RS客户端的测试工具,带UI

https://code.google.com/p/rest-client/downloads/detail?name=restclient-ui-3.2.1-jar-with-dependencies.jar&can=2&q=

posted @ 2013-11-19 16:42 paulwong 阅读(426) | 评论 (0)编辑 收藏

SPRING DATA查询方法

SPRING DATA的REPOSITORY由于只是一个接口,没有实现方法的,因此查询就要结合注释或方法进行:
通过解析方法名创建查询
通过前面的例子,读者基本上对解析方法名创建查询的方式有了一个大致的了解,这也是 Spring Data JPA 吸引开发者的一个很重要的因素。该功能其实并非 Spring Data JPA 首创,而是源自一个开源的 JPA 框架 Hades,该框架的作者 Oliver Gierke 本身又是 Spring Data JPA 项目的 Leader,所以把 Hades 的优势引入到 Spring Data JPA 也就是顺理成章的了。


框架在进行方法名解析时,会先把方法名多余的前缀截取掉,比如 find、findBy、read、readBy、get、getBy,然后对剩下部分进行解析。并且如果方法的最后一个参数是 Sort 或者 Pageable 类型,也会提取相关的信息,以便按规则进行排序或者分页查询。


在创建查询时,我们通过在方法名中使用属性名称来表达,比如 findByUserAddressZip ()。框架在解析该方法时,首先剔除 findBy,然后对剩下的属性进行解析,详细规则如下(此处假设该方法针对的域对象为 AccountInfo 类型):


先判断 userAddressZip (根据 POJO 规范,首字母变为小写,下同)是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,继续第二步;


从右往左截取第一个大写字母开头的字符串(此处为 Zip),然后检查剩下的字符串是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,则重复第二步,继续从右往左截取;最后假设 user 为 AccountInfo 的一个属性;


接着处理剩下部分( AddressZip ),先判断 user 所对应的类型是否有 addressZip 属性,如果有,则表示该方法最终是根据 "AccountInfo.user.addressZip" 的取值进行查询;否则继续按照步骤 2 的规则从右往左截取,最终表示根据 "AccountInfo.user.address.zip" 的值进行查询。


可能会存在一种特殊情况,比如 AccountInfo 包含一个 user 的属性,也有一个 userAddress 属性,此时会存在混淆。读者可以明确在属性之间加上 "_" 以显式表达意图,比如 "findByUser_AddressZip()" 或者 "findByUserAddress_Zip()"。


在查询时,通常需要同时根据多个属性进行查询,且查询的条件也格式各样(大于某个值、在某个范围等等),Spring Data JPA 为此提供了一些表达条件查询的关键字,大致如下:


And --- 等价于 SQL 中的 and 关键字,比如 findByUsernameAndPassword(String user, Striang pwd);

Or --- 等价于 SQL 中的 or 关键字,比如 findByUsernameOrAddress(String user, String addr);

Between --- 等价于 SQL 中的 between 关键字,比如 findBySalaryBetween(int max, int min);

LessThan --- 等价于 SQL 中的 "<",比如 findBySalaryLessThan(int max);

GreaterThan --- 等价于 SQL 中的">",比如 findBySalaryGreaterThan(int min);

IsNull --- 等价于 SQL 中的 "is null",比如 findByUsernameIsNull();

IsNotNull --- 等价于 SQL 中的 "is not null",比如 findByUsernameIsNotNull();

NotNull --- 与 IsNotNull 等价;

Like --- 等价于 SQL 中的 "like",比如 findByUsernameLike(String user);

NotLike --- 等价于 SQL 中的 "not like",比如 findByUsernameNotLike(String user);

OrderBy --- 等价于 SQL 中的 "order by",比如 findByUsernameOrderBySalaryAsc(String user);

Not --- 等价于 SQL 中的 "! =",比如 findByUsernameNot(String user);

In --- 等价于 SQL 中的 "in",比如 findByUsernameIn(Collection<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;

NotIn --- 等价于 SQL 中的 "not in",比如 findByUsernameNotIn(Collection<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;


同时我们也可以自定义自己的方式查询通过@Query注解 这里可以参考http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/ 这篇文章,注意的是JPA 所以@query里面的内容是HQL 如果是mongodb那么语法就是mongodb的查询语法 neo4j就是neo4j的查询语法

posted @ 2013-11-17 11:38 paulwong 阅读(432) | 评论 (0)编辑 收藏

SPRING各种例子

spring-mvc-rest
https://github.com/skprasadu/spring-mvc-rest


spring-mvc-examples
https://github.com/skprasadu/spring-mvc-examples


spring-security-examples
https://github.com/skprasadu/spring-security-examples


pro-spring-mvc-code
https://github.com/mdeinum/pro-spring-mvc-code










posted @ 2013-11-11 14:44 paulwong 阅读(366) | 评论 (0)编辑 收藏

SPRINGMVC增加LOGBACK

Maven的pom.xml增加两个JAR
<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.2</version>      
</dependency>
      
<dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.0.9</version>      
</dependency>


web.xml
<!-- spring logback -->  
<context-param>  
    <param-name>logbackConfigLocation</param-name>  
    <param-value>classpath:logback.xml</param-value>  
</context-param>    
<listener>  
    <listener-class>mypackage.LogbackConfigListener</listener-class>  
</listener>  


logback.xml
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>bookstore.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <logger name="org.springframework" level="INFO" />
    <logger name="org.springframework.web" level="INFO" />


    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <!-- <appender-ref ref="FILE" /> -->
    </root>

</configuration>



LogbackConfigurer.java
import java.io.File;
import java.io.FileNotFoundException;
import java.net.URL;

import org.slf4j.LoggerFactory;
import org.springframework.util.ResourceUtils;
import org.springframework.util.SystemPropertyUtils;

import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import ch.qos.logback.core.joran.spi.JoranException;


public abstract class LogbackConfigurer {

    /** Pseudo URL prefix for loading from the class path: "classpath:" */
    public static final String       CLASSPATH_URL_PREFIX = "classpath:";

    /** Extension that indicates a logback XML config file: ".xml" */
    public static final String       XML_FILE_EXTENSION   = ".xml";

    private static LoggerContext     lc                   = (LoggerContext) LoggerFactory.getILoggerFactory();
    private static JoranConfigurator configurator         = new JoranConfigurator();

    /**
     * Initialize logback from the given file location, with no config file refreshing. Assumes an XML file in case of a ".xml" file extension, and a properties file otherwise.
     * 
     * 
@param location
     *            the location of the config file: either a "classpath:" location (e.g. "classpath:mylogback.properties"), an absolute file URL (e.g. "file:C:/logback.properties), or a plain absolute path in the file system (e.g. "C:/logback.properties")
     * 
@throws FileNotFoundException
     *             if the location specifies an invalid file path
     
*/
    public static void initLogging(String location) throws FileNotFoundException {
        String resolvedLocation = SystemPropertyUtils.resolvePlaceholders(location);
        URL url = ResourceUtils.getURL(resolvedLocation);
        if (resolvedLocation.toLowerCase().endsWith(XML_FILE_EXTENSION)) {
//            DOMConfigurator.configure(url);
            configurator.setContext(lc);
            lc.reset();
            try {
                configurator.doConfigure(url);
            } catch (JoranException ex) {
                throw new FileNotFoundException(url.getPath());
            }
            lc.start();
        }
//        else {
//            PropertyConfigurator.configure(url);
//        }
    }

    /**
     * Shut down logback, properly releasing all file locks.
     * <p>
     * This isn't strictly necessary, but recommended for shutting down logback in a scenario where the host VM stays alive (for example, when shutting down an application in a J2EE environment).
     
*/
    public static void shutdownLogging() {
        lc.stop();
    }

    /**
     * Set the specified system property to the current working directory.
     * <p>
     * This can be used e.g. for test environments, for applications that leverage logbackWebConfigurer's "webAppRootKey" support in a web environment.
     * 
     * 
@param key
     *            system property key to use, as expected in logback configuration (for example: "demo.root", used as "${demo.root}/WEB-INF/demo.log")
     * 
@see org.springframework.web.util.logbackWebConfigurer
     
*/
    public static void setWorkingDirSystemProperty(String key) {
        System.setProperty(key, new File("").getAbsolutePath());
    }

}


LogbackWebConfigurer.java
import java.io.FileNotFoundException;

import javax.servlet.ServletContext;

import org.springframework.util.ResourceUtils;
import org.springframework.util.SystemPropertyUtils;
import org.springframework.web.util.WebUtils;

public abstract class LogbackWebConfigurer {

    /** Parameter specifying the location of the logback config file */
    public static final String CONFIG_LOCATION_PARAM     = "logbackConfigLocation";

    /** Parameter specifying the refresh interval for checking the logback config file */
    public static final String REFRESH_INTERVAL_PARAM    = "logbackRefreshInterval";

    /** Parameter specifying whether to expose the web app root system property */
    public static final String EXPOSE_WEB_APP_ROOT_PARAM = "logbackExposeWebAppRoot";

    /**
     * Initialize logback, including setting the web app root system property.
     * 
     * 
@param servletContext
     *            the current ServletContext
     * 
@see WebUtils#setWebAppRootSystemProperty
     
*/
    public static void initLogging(ServletContext servletContext) {
        // Expose the web app root system property.
        if (exposeWebAppRoot(servletContext)) {
            WebUtils.setWebAppRootSystemProperty(servletContext);
        }

        // Only perform custom logback initialization in case of a config file.
        String location = servletContext.getInitParameter(CONFIG_LOCATION_PARAM);
        if (location != null) {
            // Perform actual logback initialization; else rely on logback's default initialization.
            try {
                // Return a URL (e.g. "classpath:" or "file:") as-is;
                
// consider a plain file path as relative to the web application root directory.
                if (!ResourceUtils.isUrl(location)) {
                    // Resolve system property placeholders before resolving real path.
                    location = SystemPropertyUtils.resolvePlaceholders(location);
                    location = WebUtils.getRealPath(servletContext, location);
                }

                // Write log message to server log.
                servletContext.log("Initializing logback from [" + location + "]");

                // Initialize without refresh check, i.e. without logback's watchdog thread.
                LogbackConfigurer.initLogging(location);

            } catch (FileNotFoundException ex) {
                throw new IllegalArgumentException("Invalid 'logbackConfigLocation' parameter: " + ex.getMessage());
            }
        }
    }

    /**
     * Shut down logback, properly releasing all file locks and resetting the web app root system property.
     * 
     * 
@param servletContext
     *            the current ServletContext
     * 
@see WebUtils#removeWebAppRootSystemProperty
     
*/
    public static void shutdownLogging(ServletContext servletContext) {
        servletContext.log("Shutting down logback");
        try {
            LogbackConfigurer.shutdownLogging();
        } finally {
            // Remove the web app root system property.
            if (exposeWebAppRoot(servletContext)) {
                WebUtils.removeWebAppRootSystemProperty(servletContext);
            }
        }
    }

    /**
     * Return whether to expose the web app root system property, checking the corresponding ServletContext init parameter.
     * 
     * 
@see #EXPOSE_WEB_APP_ROOT_PARAM
     
*/
    private static boolean exposeWebAppRoot(ServletContext servletContext) {
        String exposeWebAppRootParam = servletContext.getInitParameter(EXPOSE_WEB_APP_ROOT_PARAM);
        return (exposeWebAppRootParam == null || Boolean.valueOf(exposeWebAppRootParam));
    }

}


LogbackConfigListener.java
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class LogbackConfigListener implements ServletContextListener {

    public void contextInitialized(ServletContextEvent event) {
        LogbackWebConfigurer.initLogging(event.getServletContext());
    }

    public void contextDestroyed(ServletContextEvent event) {
        LogbackWebConfigurer.shutdownLogging(event.getServletContext());
    }
}



posted @ 2013-11-11 13:44 paulwong 阅读(4755) | 评论 (0)编辑 收藏

大型网站技术架构读书笔记

大型网站经历的技术架构演变:
  1. 应用服务器、数据库服务器和文件服务器都安装在同一台主机
  2. 应用服务器、数据库服务器和文件服务器分别安装在不同主机
  3. 增加了分布式的缓存服务器
  4. 应用服务器增加了好几台,变成集群
  5. 增加了CDN和反射代理服务器
  6. 数据库服务器变成主从形式的服务器
  7. 数据库服务器变成分布式的服务器,文件服务器也变成分布式服务器
  8. NOSQL分布式数据库和搜索引擎的引入
  9. 应用服务器虽然是多台,但都是部署了同一应用,这时将应用拆分,每台服务器部署不同的拆分应用
  10. 虽然应用已经拆分,但每个应用都是从页面管到数据库,这时继续拆分,将存取数据库的部份独立,页面部份
    也独立
架构模式
  1. 分层,代码放在不同的类中
  2. 分割,应用放在不同的JVM中
  3. 分布式,部署在不同的物理机
  4. 集群,同一个应用部署到不同的主机,可以负载均衡
  5. 缓存,CND加速、反向代理、本地缓存、分布式缓存
  6. 异步,消除高并发
  7. 冗余,多处备份
  8. 安全性

posted @ 2013-11-09 11:34 paulwong 阅读(648) | 评论 (0)编辑 收藏

Java EE 8愿望清单:缺少这些,Java EE将不会完美

摘要:Java EE 7已于6月中旬正式发布,尽管新平台包含了诸多新的特性,但是开发者对此似乎并不满足,他们期待未来的版本Java EE 8中能够包含更完善的特性,比如更大的CDI应用范围、标准的缓存API、现代化的安全框架等。

Java EE 7已于6月中旬正式发布,新版本提供了一个强大、完整、全面的堆栈来帮助开发者构建企业和Web应用程序——为构建HTML5动态可伸缩应用程序提供了支持,并新增大量规范和特性来提高开发人员的生产力以及满足企业最苛刻的需求。

下面的这个图表包含了Java EE 7中的各种组件。橙色部分为Java EE中新添加的组件。

尽管新的平台包含了诸多新的特性,但是开发者对此似乎并不满足,尽管他们中的大部分还没有迁移到Java EE 7(或许是由于Java EE 7的特性还不完善),但是这并不影响他们对于Java EE 8特性的设想。

比如,在Java EE 6发布(2009年12月10日发布)后,开发者Antonio Goncalves认为该版本并没有解决一些问题,因此写了一个希望在Java EE 7中包含的特性清单。有趣的是,他写的4个特性中,其中有2个(flows和batch)已经包含在Java EE 7中了,而第3个特性(caching)原本也计划包含其中,但由于开发进度关系,在Java EE 7最终发布前被舍弃。

此举促使开发者Arjan Tijms也写了一个他希望在Java EE 8中出现的特性清单,如下。

  1. 无处不在的CDI(Contexts and Dependency Injection for Java EE,上下文与依赖注入)
  2. 更深入的Pruning(修剪)和Deprecating(弃用)
  3. 一个标准的缓存API
  4. administrative objects(管理对象)的应用内替代品
  5. 综合的现代化的安全框架
  6. 平台范围内的配置

下面就来详细阐述这些特性的必要性。

1.  无处不在的CDI

实际上这意味着2种不同的东西:使CDI可以用在目前不能用的其他地方、基于CDI来实现和改造其他规范中的相关技术。

a. 使CDI可以用在其他地方

与Java EE 6相比,Java EE 7中的CDI的适用范围已经扩大了很多,比如CDI注入现在可以工作在大多数JSF组件(artifacts)中,比如基于bean validation的约束验证器。不幸的是,只是大部分JSF组件,并非所有的,比如转换器和验证器就不行,尽管OmniFaces 1.6将支持这些特性,但最好是在Java EE 7中能够开箱即用。

此外,Java EE 7中的CDI也没有考虑到JASPIC组件,在此之中注入操作将无法工作。即使http请求和会话在Servlet Profile SAM中可用,但是当SAM被调用时,相应的CDI作用域也不会被建立。这意味着它甚至不能通过bean管理器以编程方式来检索请求或会话bean作用域。

还有一种特殊情况是,各种各样的平台artifacts可以通过一些替代的注解(如@PersistenceUnit)来注入,但早期的注入注解(@Resource)仍然需要做很多事情,比如DataSource。即使Java EE 7中引入了artifacts(如任务调度服务),但也不得不通过“古老”的@Resource来注入,而不是通过@Inject。

b. 基于CDI来实现和改造其他规范中的相关技术

CDI绝对不应该只专注于在其他规范中已经解决的那些问题,其他规范还可以在CDI之上来实现它们各自的功能,这意味着它们可以作为CDI扩展。以Java EE 7中的JSF 2.2为例,该规范中的兼容CDI的视图作用域可作为CDI扩展来使用,并且其新的flow作用域也可被立即实现为CDI扩展。

此外,JTA 1.2现在也提供了一个CDI扩展,其可以声明式地应用到CDI托管的bean中。此前EJB也提供了类似的功能,其背后技术也使用到了JTA,但是声明部分还是基于EJB规范。在这种情况下,可以通过JTA来直接处理其自身的声明性事务,但是这需要在CDI之上进行。

尽管从EJB 3版本开始,EJB beans已经非常简单易用了,同时还相当强大,但问题是:CDI中已经提供了组件模型,EJB beans只是另一个替代品。无论各种EJB bean类型有多么实用,但是一个平台上有2个组件模型,容易让用户甚至是规范实现者混淆。通过CDI组件模型,你可以选择需要的功能,或者混合使用,并且每个注解提供了额外的功能。而EJB是一个“一体”模式,在一个单一的注解中定义了特定的bean类型,它们之间可以很好地协同工作。你可以禁用部分不想使用的功能。例如,你可以关闭bean类型中提供的事务支持,或者禁用@Stateful beans中的passivation,或者禁用@Singleton beans中的容器管理锁。

如果EJB被当做CDI的一组扩展来进行改造,可能最终会更好。这样就会只有一个组件模型,并且具有同样有效的功能。

这意味着EJB的服务,如计时器服务(@Schedule@TimeOut )、@Asynchronous、 @Lock@Startup/@DependsOn和@RolesAllowed都应该能与CDI托管的bean一起工作。此外,现有EJB bean类型提供的隐式功能也应该被分解成可单独使用的功能。比如可以通过@Pooled来模拟@Stateless beans提供的容器池,通过@CallScoped来模拟调用@Stateless bean到不同的实例中的行为。

2.  更深入的Pruning(修剪)和Deprecating(弃用)

在Java EE平台中,为数众多的API可能会令初学者不知所措,这也是导致Java EE如此复杂的一个重要原因。因此从Java EE 6版本开始就引入了Pruning(修剪)和Deprecating(弃用)过程。在Java EE 7中,更多的技术和API成为了可选项,这意味着开发者如果需要,还可以包含进来。

比如我个人最喜欢的是JSF本地托管bean设施、JSP视图处理程序(这早在2009年就被弃用了),以及JSF中各种各样的功能,这些功能在规范文件中很长一段时间一直被描述为“被弃用”。

如果EJB组件模型也被修剪将会更好,但这有可能还为时过早。其实最应该做的是继续去修剪EJB 2编程模型相关的所有东西,比如在Java EE 7中依然存在的home接口。

3.  一个标准化的缓存API

JCache缓存API原本将包含在Java EE 7中,但不幸的是,该API错过了重要的公共审查的最后期限,导致其没能成为Java EE 7的一部分。

如果该规范能够在Java EE 8计划表的早期阶段完成,就有可能成为Java EE 8的一部分。这样,其他一些规范(如JPA)也能够在JCache之上重新构建自己的缓存API。

4.  所有管理对象(administrative objects)的应用内替代品

Java EE中有一个概念叫“管理对象(administrative objects)”。这是一个配置在AS端而不是在应用程序本身中的资源。这个概念是有争议的。

对于在应用服务器上运行许多外部程序的大企业而言,这可以是一个大的优势——你通常不会想去打开一个外部获得的应用程序来改变它连接的数据库的相关细节。在传统企业中,如果在开发人员和操作之间有一个强大的分离机制,这个概念也是有益的——这可以在系统安装时分别设置。

但是,这对于在自己的应用服务器部署内部开发的应用程序的敏捷团队来说,这种分离方式是一个很大的障碍,不会带来任何帮助。同样,对于初学者、教育方面的应用或者云部署来说,这种设置也是非常不可取的。

从Java EE 6的@DataSourceDefinition开始,许多资源(早期的“管理对象”)只能从应用程序内部被定义,比如JMS Destinations、email会话等。不幸的是,这并不适用于所有的管理对象。

不过,Java EE 7中新的Concurrency Utils for Java EE规范中有明确的选项使得它的资源只针对管理对象。如果在Java EE 8中,允许以一个便携的方式从应用程序内部配置,那么这将是非常棒的。更进一步来说,如果Java EE 8中能够定义一种规范来明确禁止资源只能被administrative,那么会更好。

5.  综合的现代化的安全框架

在Java EE中,安全一直是一个棘手的问题。缺乏整体和全面的安全框架是Java EE的主要缺点之一,尤其是在讨论或评估竞争框架(如Spring)时,这些问题会被更多地提及。

并不是Java EE没有关于安全方面的规定。事实上,它有一整套选项,比如JAAS、JASPIC、JACC、部分的Servlet安全方面的规范、部分EJB规范、JAX-RS自己的API,甚至JCA也有一些自己的安全规定。但是,这方面存在相当多的问题。

首先,安全标准被分布在这么多规范中,且并不是所有这些规范都可以用在Java EE Web Profile中,这也导致难以推出一个综合的Java EE安全框架。

第二,各种安全API已经相当长一段时间没有被现代化,尤其是JASPIC和JACC。长期以来,这些API只是修复了一些小的重要的问题,从来没有一个API像JMS 2一样被完整地现代化。比如,JASPIC现在仍然针对Java SE 1.4

第三,个别安全API,如JAAS、JASPIC 和JACC,都是比较抽象和低层次的。虽然这为供应商提供了很大的灵活性,但是它们不适合普通的应用程序开发者。

第四,最重要的问题是,Java EE中的安全机制也遭遇到了“管理对象”中同样的问题。很长一段时间,所谓的Java EE声明式安全模型主要认证过程是在AS端按照供应商特定方式来单独配置和实现的,这再次让安全设置对于敏捷团队、教育工作者和初学者来说成为一件困难的事。

以上这些是主要的问题。虽然其中一些问题可以在最近的Java EE升级中通过增加小功能和修复问题来解决。然而,我的愿望是,能够在Java EE 8中,通过一个综合的和现代化的安全框架(尽可能地构建在现有安全基础上)将这些问题解决得更加彻底。

6.  平台范围内的配置

Java EE应用程序可以使用部署描述文件(比如web.xml)进行配置,但该方法对于不同的开发阶段(如DEV、BETA、LIVE等)来说是比较痛苦的。针对这些阶段配置Java EE应用程序的传统的方法是通过驻留在一个特定服务器实例中的“管理对象”来实现。在该方法中,配置的是服务器,而不是应用程序。由于不同阶段会对应不同的服务器,因此这些设置也会随之自动改变。

这种方法有一些问题。首先在AS端的配置资源是服务器特定的,这些资源可以被标准化,但是它们的配置肯定没有被标准化。这对于初学者来说,在即将发布的应用程序中进行解释说明比较困难。对于小型开发团队和敏捷开发团队而言,也增加了不必要的困难。

对于配置Java EE应用程序,目前有很多可替代的方式,比如在部署描述符内使用(基于表达式语言的)占位符,并使部署描述符(或fragments)可切换。许多规范已经允许指定外部的部署描述符(如web.xml中可以指定外部的faces-config.xml文件,persistence.xml中可以指定外部的orm.xml文件),但是没有一个统一的机制来针对描述符做这些事情,并且没有办法去参数化这些包含的外部文件。

如果Java EE 8能够以一种彻底的、统一平台的方式来解决这些配置问题,将再好不过了。似乎Java EE 8开发团队正在计划做这样的事情。这将会非常有趣,接下来就看如何发展了。

结论

Java EE 8目前尚处于规划初期,但愿上面提到的大多数特性能够以某种方式加以解决。可能“无处不在的CDI”的几率会大一些,此方面似乎已经得到了很大的支持,且事情已经在朝着这个方向发展了。

标准化缓存API也非常有可能,它几乎快被包含在Java EE 7中了,但愿其不会再次错过规范审查的最后期限。

此外,“现代化的安全框架”这一特性已经被几个Java EE开发成员提到,但是此方面工作尚未启动。这可能需要相当大的努力,以及大量其他规范的支持,这是一个整体性问题。顺便说一句,安全框架也是Antonio Goncalves关于Java EE 7愿望清单中的第4个提议,希望Java EE 8可以解决这一问题。

posted @ 2013-11-09 11:14 paulwong 阅读(534) | 评论 (0)编辑 收藏

仅列出标题
共112页: First 上一页 55 56 57 58 59 60 61 62 63 下一页 Last