jersey学习笔记3-集成服务

最新推荐文章于 2023-12-28 00:11:42 发布
最新推荐文章于 2023-12-28 00:11:42 发布
阅读量862 收藏
点赞数
分类专栏： JAVA jersey 文章标签： JAVA jersey
JAVA 同时被 2 个专栏收录
16 篇文章 1 订阅
订阅专栏
jersey
3 篇文章 0 订阅
订阅专栏

集成服务

依赖包的引入

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>simple-service-webapp</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>simple-service-webapp</name>

    <properties>
        <JDK.version>1.7</JDK.version>
        <jersey.version>2.25</jersey.version>
        <junit.version>4.12</junit.version>
        <slf4j.version>1.7.21</slf4j.version>
        <log4j.version>1.2.17</log4j.version>

        <spring.version>3.2.17.RELEASE</spring.version>
        <jquery.version>3.1.1</jquery.version>
        <mysql-connector.version>5.1.38</mysql-connector.version>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven-compiler-plugin.version>2.5.1</maven-compiler-plugin.version>
        <maven-war-plugin.version>2.3</maven-war-plugin.version>
        <maven-resources-plugin.version>2.6</maven-resources-plugin.version>
        <maven-eclipse-plugin.version>2.9</maven-eclipse-plugin.version>

        <jetty.version>6.1.5</jetty.version>
        <mybatis.version>3.4.1</mybatis.version>
        <mybatis-spring.version>1.3.0</mybatis-spring.version>
        <commons-dbcp.version>1.4</commons-dbcp.version>
        <aspectjweaver.version>1.8.9</aspectjweaver.version>
        <aopalliance.version>1.0</aopalliance.version>

    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
                    <source>${JDK.version}</source>
                    <target>${JDK.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>${maven-war-plugin.version}</version>
            </plugin>
            <plugin>
                <!-- support eclipse's web server -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>${maven-eclipse-plugin.version}</version>
                <configuration>
                    <downloadSources>false</downloadSources>
                    <wtpversion>2.0</wtpversion>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>${maven-resources-plugin.version}</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>${jetty.version}</version>
            </plugin>
        </plugins>
    </build>

    <dependencies>

        <!-- jersey -->
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-servlet</artifactId>
            <version>${jersey.version}</version>
        </dependency>

        <!-- media type -->
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-moxy</artifactId>
            <version>${jersey.version}</version>
        </dependency>

        <!-- jersey-spring -->
        <dependency>
            <groupId>org.glassfish.jersey.ext</groupId>
            <artifactId>jersey-spring3</artifactId>
            <version>${jersey.version}</version>
        </dependency>

        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- unit test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.jersey.test-framework</groupId>
            <artifactId>jersey-test-framework-core</artifactId>
            <version>${jersey.version}</version>
        </dependency>

        <!-- Jersey test containers -->
        <dependency>
            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
            <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
            <version>${jersey.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
            <artifactId>jersey-test-framework-provider-inmemory</artifactId>
            <version>${jersey.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
            <artifactId>jersey-test-framework-provider-jdk-http</artifactId>
            <version>${jersey.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
            <artifactId>jersey-test-framework-provider-simple</artifactId>
            <version>${jersey.version}</version>
        </dependency>

        <!-- web jars -->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>${jquery.version}</version>
        </dependency>

        <!-- log -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
            <!--<scope>runtime</scope> -->
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- aop，事务控制 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>${aopalliance.version}</version>
        </dependency>

        <!-- db -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector.version}</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>${commons-dbcp.version}</version>
        </dependency>

    </dependencies>

    <pluginRepositories>
        <pluginRepository>
            <id>snapshots.codehaus.org</id>
            <name>Codehaus.org Snapshots Maven Repository</name>
            <url>http://nexus.codehaus.org/snapshots</url>
            <layout>default</layout>
        </pluginRepository>
    </pluginRepositories>

    <repositories>
        <repository>
            <id>release.maven.java.net</id>
            <name>java.net Maven Release Repository</name>
            <url>https://maven.java.net/content/groups/public</url>
            <layout>default</layout>
        </repository>
    </repositories>
</project>

该工程集成spring和mybatis，使用mysql数据库。

集成spring

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/util  
        http://www.springframework.org/schema/util/spring-util-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

    <!-- 对包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 -->
    <context:component-scan base-package="com.example" />

    <!-- aop配置 -->
    <aop:aspectj-autoproxy />

    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${username}"></property>
        <property name="password" value="${password}"></property>
        <property name="initialSize" value="${initialSize}"></property>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="${maxActive}"></property>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="${maxIdle}"></property>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="${minIdle}"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="${maxWait}"></property>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mapper/configuration.xml"></property>
    </bean>


    <!-- 配置事务管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 事务注解驱动，标注@Transactional的类和方法将具有事务性 -->
    <tx:annotation-driven transaction-manager="txManager" proxy-target-class="true" />

</beans>

在web.xml中配置spring:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name>simple-service-webapp</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

</web-app>


数据库配置

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.183.129:3306/mysql?useUnicode=true&characterEncoding=UTF-8
username=root
password=duckking
initialSize=0
maxActive=20
maxIdle=20
minIdle=1
maxWait=60000

上面是jdbc.properties的内容，定义了数据库的属性。这些属性在spring的配置中读取。


创建数据库连接

在spring的配置中创建数据库连接，用的是dhcp的代码来创建的：

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${username}"></property>
        <property name="password" value="${password}"></property>
        <property name="initialSize" value="${initialSize}"></property>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="${maxActive}"></property>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="${maxIdle}"></property>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="${minIdle}"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="${maxWait}"></property>
    </bean>


集成mybatis

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mapper/configuration.xml"></property>
    </bean>

用SqlSessionFactoryBean初始化数据，配置文件是configuration.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.4//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="Book" type="com.example.bo.Book" />
        <typeAlias alias="Books" type="com.example.bo.Books" />
    </typeAliases>
    <mappers>
        <mapper resource="mapper/books.xml" />
    </mappers>
</configuration>


mybatis使用数据库的mapper如下：books.xml

<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.4//EN"   
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="default namespace">

</mapper>

现在我们建立起了一个由jersey提供api，后端集成了spring和mybatis的框架，还有一引动其它的小功能，如日志、测试等，但里面内容还是空的，现在我们向时面加内容。


定义实体类

@XmlRootElement
public class Book {
    private Long bookId;
    private String bookName;
    private String publisher;

    @XmlAttribute
    public Long getBookId() {
        return bookId;
    }

    public void setBookId(Long bookId) {
        this.bookId = bookId;
    }

    @XmlAttribute
    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    @XmlAttribute
    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
}


@XmlRootElement(name = "books")
public class Books implements Serializable {
    /**
     *
     */
    private static final long serialVersionUID = 1398511916695349225L;

    private List<Book> bookList;

    @XmlElement(name = "book")
    @XmlElementWrapper
    public List<Book> getBookList() {
        return bookList;
    }

    public void setBookList(List<Book> bookList) {
        this.bookList = bookList;
    }

}


定义资源类

@Path("books")
public class BookResource {

    private static final Logger logger = LoggerFactory.getLogger(BookResource.class);

    @Autowired
    private BookService bookService;

    @GET
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
    public Books getAlBooks() {
        final Books books = bookService.getAllBooks();
        return books;
    }
    
    @Path("{bookId:[0-9]*}")
    @GET
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
    public Book getBookByPath(@PathParam("bookId") final Long bookId) {
        logger.info("bookId=" + bookId);
        final Book book = bookService.getBook(bookId);
        return book;
    }

    @Path("/book")
    @GET
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
    public Book getBookByQuery(@QueryParam("id") final Long bookId) {
        final Book book = bookService.getBook(bookId);
        return book;
    }
}

上述三个方法访问的方式分别为：

http://localhost:8080/simple-service-webapp/webapi/books

http://localhost:8080/simple-service-webapp/webapi/books/1

http://localhost:8080/simple-service-webapp/webapi/books/book?id=1

中间service层没有什么好说的，看下Dao层：

@Repository("bookDao")
public class BookDao extends SqlSessionDaoSupport {

    @Autowired
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        super.setSqlSessionFactory(sqlSessionFactory);
    }

    public Books getAllBooks() {
        List<Book> bookList = this.getSqlSession().selectList("getAllBooks");
        Books books = new Books();
        books.setBookList(bookList);
        return books;
    }
    
    public Book findById(final String bookId) {
        logger.info("bookId=" + bookId);
        return (Book) this.getSqlSession().selectOne("findById", bookId);
    }
}

在执行过程中可以看到后台日志：

[DEBUG] 2016-12-12 22:39:37,113 method:org.mybatis.spring.SqlSessionUtils.getSqlSession(SqlSessionUtils.java:99)
Creating a new SqlSession
[DEBUG] 2016-12-12 22:39:37,113 method:org.mybatis.spring.SqlSessionUtils.registerSessionHolder(SqlSessionUtils.java:150)
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1a753a0] was not registered for synchronization because synchronization is not active
[DEBUG] 2016-12-12 22:39:37,114 method:org.springframework.jdbc.datasource.DataSourceUtils.doGetConnection(DataSourceUtils.java:110)
Fetching JDBC Connection from DataSource
[DEBUG] 2016-12-12 22:39:37,118 method:org.mybatis.spring.transaction.SpringManagedTransaction.openConnection(SpringManagedTransaction.java:89)
JDBC Connection [jdbc:mysql://192.168.183.129:3306/mysql?useUnicode=true&characterEncoding=UTF-8, UserName=root@192.168.183.1, MySQL Connector Java] will not be managed
 by Spring
[DEBUG] 2016-12-12 22:39:37,119 method:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug(BaseJdbcLogger.java:145)
==>  Preparing: SELECT bookid,bookname,publisher FROM book where bookid=?
[DEBUG] 2016-12-12 22:39:37,121 method:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug(BaseJdbcLogger.java:145)
==> Parameters: 1(String)
[DEBUG] 2016-12-12 22:39:37,125 method:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug(BaseJdbcLogger.java:145)
<==      Total: 1
[DEBUG] 2016-12-12 22:39:37,125 method:org.mybatis.spring.SqlSessionUtils.closeSqlSession(SqlSessionUtils.java:193)
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1a753a0]
[DEBUG] 2016-12-12 22:39:37,126 method:org.springframework.jdbc.datasource.DataSourceUtils.doReleaseConnection(DataSourceUtils.java:327)
Returning JDBC Connection to DataSource


发布服务

定义一个application类，由application类发布接口：

public class AirApplication2 extends ResourceConfig {

    public AirApplication2() {
        packages("com.example.resource");
    }
}

将Application启动，在web.xml中配置。

    <servlet>
        <servlet-name>Jersey Web Application</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>javax.ws.rs.Application</param-name>
            <param-value>com.example.AirApplication2</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Jersey Web Application</servlet-name>
        <url-pattern>/webapi/*</url-pattern>
    </servlet-mapping>

一个后台服务就发布完成了，可以通过浏览器直接访问url的方式访问api了。


前台框架jQuery

我们前端使用augularJS来实现，这里不讲解jQuery通过Ajax来访问后台的具体内容。

测试框架

通过firefox的resteasy或rested插件来进行测试。


k_morningsky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink需要的jersey-core和jersey-client
03-01
如果flink提交jar到yarn上运行报如下错误：java.lang.NoClassDefFoundError: com/sun/jersey/core/util/FeaturesAndProperties,在flink的lib包里面添加这两个jar包
Jersey用户指南（2）
xueqing90的博客
04-06 2806
第二章。模块和依赖关系 表的内容 2.1。Java SE的兼容性 2.2。介绍球衣依赖性 2.3。常见的球衣用例 2.3.1。Glassfish上基于Servlet的应用程序 2.3.2。基于Servlet的服务器端应用程序 2.3.3。客户端应用程序在JDK 2.3.4。服务器端应用程序容器的支持 2.4。Jersey 的模块列表 2.1。Java SE的兼容性 直至Jer
Jersey单元测试
每天进步一点点
08-15 850
1、jar包 &lt;dependency&gt; &lt;groupId&gt;org.glassfish.jersey.test-framework.providers&lt;/groupId&gt; &lt;artifactId&gt;jersey-test-framework-provider-grizzly2&lt;/artifactId&gt; &lt;ver...
Jersey入门到放弃-3
chenghang8910的博客
04-11 909
1. Jersey与JDK的兼容性 Jersey version JDK version 2.6- 6.0 2.6+ 7.0（core-common and core-client支持6.0） ...
SpringBoot——集成Jersey
最新发布
吴声子夜歌的博客
12-28 645
在Jersey中引入Spring MVC会带来根路径冲突的问题，因为它们各自的Servlet都默认处理根路径。注意：jersety starter模式使用jackson解析JSON。声明根路径，那么yml中的配置会覆盖注解中的配置。，jersey的跟路径为。actuator的端口为。注意，如果同时也使用了。，jersey的端口为。
Jersey 开发RESTful（十一）Entity Provider
wolfcode_cn的博客
06-25 1385
【原创文章，转载请注明原文章地址，谢谢！】本节开始，进入Jersey的Provider介绍。本节介绍的是Jersey提供的最简单的两个Provider：MessageBodyWriter和MessageBodyReader。每一个涉及到输入输出的框架都会存在输入输出转化的问题。比如接受到一个请求，应该以什么样的方式去处理请求？应该由谁来把请求里面的内容按照什么样的方式转化成应用需要的数据。一个资源...
jersey-media-jaxb-2.22.2-API文档-中英对照版.zip
04-19
赠送jar包：jersey-media-jaxb-2.22.2.jar； 赠送原API文档：jersey-media-jaxb-2.22.2-javadoc.jar； 赠送源代码：jersey-media-jaxb-2.22.2-sources.jar； 赠送Maven依赖信息文件：jersey-media-jaxb-2.22.2.pom；...
jersey-core、jersey-client jar包.rar
07-26
jersey-core是Jersey的核心模块，包含实现JAX-RS标准所需的基本组件和服务。它提供了HTTP请求和响应的抽象，以及用于处理URI模板、实体编码、异常处理、元数据等的功能。这个库使得开发者能够轻松地创建RESTful服务...
jersey-container-servlet-core-2.22.2-API文档-中文版.zip
05-01
赠送jar包：jersey-container-servlet-core-2.22.2.jar； 赠送原API文档：jersey-container-servlet-core-2.22.2-javadoc.jar； 赠送源代码：jersey-container-servlet-core-2.22.2-sources.jar； 赠送Maven依赖信息...
jersey-spring3-2.4.1.jar
06-04
Jersey-spring3-2.4.1.jar
Jersey+Spring集成，后台接受或返回Json数据
04-22
NULL 博文链接：https://arthur8.iteye.com/blog/1954736
jersey框架统一异常处理时的注意事项
qq_36457702的博客
12-04 481
1、统一异常处理时需要实现ExceptionMapper接口、重写toResponse方法 toResponse方法例子： @Override public Response toResponse(Exception throwable) { if (Objects.isNull(throwable)) { return Response.serverError()...
如何将Jersey集成到Spring MVC应用程序中
最佳 Java 编程
05-26 299
我最近开始使用Java为Podcastpedia.org和JAX-RS实现构建公共的REST API，我选择了Jersey ，因为我发现它“自然”且功能强大-您可以通过遵循教程了解更多信息-带有Jersey和Spring的Java中的REST API设计和实现。 由于Podcastpedia.org是由Spring MVC支持的Web应用程序，因此我想将这两个框架都集成在podcastped...
Spring 完美整合 Jersey
Tank_up的博客
10-30 8172
一、前言 Jersey 这是一个非常优秀的框架，是一个实现了RESTful的webservice框架, 属于glassfish项目.官方网站: http://jersey.com/jersey目前的中文文档比较少, 官方的例子使用了maven来构建，网上也没有直接使用jar的demo,而我刚好 公司需要做这个，在解决各种坑之后决定分享给大家。什么是RESTful? REST是设计风格而不是标
jersey_实施Jersey 2 Spring集成
cunhui1209的博客
12-13 166
jersey Jersey是Oracle提供的出色的Java JAX-RS规范参考实现。 去年，当我们开始为大容量网站构建RESTful后端Web服务时，我们选择使用JAX-RS API作为我们的REST框架和用于依赖项注入的Spring框架。 泽西岛是我们选择的JAX-RS实现。 项目启动时，JAX-RS API 2.0规范尚未发布，Jersey 2.0也未发布。 由于我们没有发现JAX-R...
Spring与jersey整合Ⅱ
谢耀眼
03-24 2355
文章目录Spring与jersey整合工程目录配置文件maven配置文件web.xmlrequest和response拦截web.xmlJava输出@Consumes("application/json")@Produces("application/json")@Provider Spring与jersey整合 工程目录 配置文件 maven配置文件 <?xml version="1.0...
Jersey实现对方法进行过滤拦截
热门推荐
无德皇叔的博客
06-08 1万+
在web程序开发过程中，通常我们会需要对我们的接口进行访问控制，例如控制用户的访问权限、记录用户的访问日志等，在我们使用Jersey进行Restful服务开发中，同样会有类似需求，下面我们介绍下，使用Jersey框架，实现接口访问的三种方式。 一、使用注解名称绑定过滤器 1.1 创建名称绑定注解     使用@NameBinding注解，可以定义一个运行时的自定义注解，该注解
RedHat yum源配置
MCN的博客
10-30 1112
Jersey提供了支持Spring DI的扩展。这使得Jersey可以使用Spring bean作为JAX-RS组件（例如资源和提供者），并且还允许Spring注入到被Jersey管理的组件中。 Spring扩展模块配置是基于注解的。 Spring bean被注入，JAX-RS类使用注解后被Spring管理。 注入Spring bean可以使用Spring XML配置注入更多的依赖关系。......
Spring4- 04-Spring简易整合Mybatis -导入jar包/ 正常编写pojo/ 编写spring 配置文件
weixin_30376083的博客
12-08 64
笔记要点&出错分析与总结 　　POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，工程组织 (AirportService为机场服务站接口,定义了 List<Airport> show(); package com03.service; import com03.bean.Airport;...
spring-boot-starter-jersey调python服务
08-19
在Spring Boot中，使用spring-boot-starter-jersey可以方便地集成Jersey框架来调用Python服务。spring-boot-starter-jersey是一个starter，它会自动配置Jersey框架所需的依赖项和配置。你只需要在项目的pom.xml文件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值