基于restful注解(spring4.0.2整合flex+blazeds+spring-mvc)
webflux用法
webflux用法WebFlux是SpringFramework的一个新特性，它为SpringWeb开发提供了更为简洁、高效和安全的方式。
通过使用WebFlux，开发者可以更轻松地构建RESTfulAPI，并充分利用Spring框架的强大功能。
一、基本用法1.创建WebFlux应用程序要使用WebFlux，首先需要在SpringBoot应用程序中启用它。
可以通过在主应用类上添加@WebFlux注解来启用WebFlux。
2.处理请求在WebFlux中，处理请求是通过方法注解来实现的。
常用的注解包括@GetMapping、@PostMapping、@PutMapping、@DeleteMapping等。
这些注解会将方法与HTTP方法（如GET、POST、PUT、DELETE等）进行映射，并处理相应的请求。
例如，以下代码定义了一个处理GET请求的简单页面：```kotlin@GetMapping("/hello")publicStringhello(){return"Hello,World!";}```3.使用响应处理程序在WebFlux中，响应处理程序是通过ResponseBody注解来定义的。
它可以指定响应的格式（如String、Object、Stream等），并允许开发者自定义响应的内容。
例如，以下代码将返回一个包含问候语的JSON响应：```arduino@GetMapping("/greeting")publicResponseEntity<Greeting>greeting(){Greetinggreeting=newGreeting(LocalDateTime.now());returnResponseEntity.ok(greeting);}```二、高级用法1.异步处理请求WebFlux支持异步处理请求，这可以通过使用CompletableFuture或使用Reactor中的Flux和Mono实现。
FLEX4_Flex4教程
Flex 应用的构建形式 尽管用 Flex 开发 RIA 有多种形式，但现在主流的架构是：Flex 作为 Client（客户端），Java、PHP、 Asp、Ruby 等技术作为 Server（服务器端）。
本教程之后的内容主要介绍 Flex 与 Java 技术的整合。
Flex 访问服务器端数据的 3 种方式 既然 Flex 可以和 Java 等 Sever 端技术整合，那么它们之间怎样实现通信的呢？Flex 通过 HTTPService，WebService 和 RemoteObject 这 3 个组件实现与 Server 端的通信。
外观与样式设计 使用 CSS 和图形属性编辑器自定义应用程序外观。快速设置最常用的属性，并在“Design”（设计） 视图中预览结果。使用新的 Theme Browser（主题浏览器）浏览可用主题，并将它们应用于您的项目。
与 Adobe Creative Suite 设计工具集成 导入使用 Adobe Flash Professional、Illustrator®、Photoshop® 或 Fireworks® 软件创建的设计 资源，或导入使用 Flash Catalyst 创建的整个应用程序用户界面。Flash Professional 与 Flash Builder 之间的新工作流程简化了自定义 Flex 组件的导入和更新。
HTTPService 组件
HTTPService 组件允许你与 HTTP 服务交互，可以是接收 HTTP 请求和发送 HTTP 响应的任何 HTTP URI。 你可以通过 HTTPService 组件调用任何类型的 Server 端技术，包括 PHP pages, ColdFusion Pages, JavaServer Pages, Java servlets, Ruby on Rails 和 ASP pages。 HTTPService 组件允许你发送 HTTP GET、POST、HEAD、OPTIONS、PUT、TRACE 和 DELETE 请求，并典 型的以 XML 形式返回。
restful协议
restful协议REST（Representational State Transfer，表示状态转移）是一种设计风格，用于构建分布式网络系统中的Web服务。
它基于HTTP协议，通过使用标准的HTTP方法（GET、POST、PUT、DELETE等）和URL来实现资源的CRUD操作（创建、读取、更新、删除）。
RESTful协议是一种符合REST原则的设计规范，下面将详细介绍一下。
首先，RESTful协议强调资源的抽象。
每个资源在系统中都是唯一的，并通过URL进行标识。
通过URL，可以使用HTTP方法对资源进行操作。
例如，对于一个用户资源，可以使用URL `/users`（表示用户）进行创建、读取、更新和删除操作。
其次，RESTful协议提供了一组统一的HTTP方法来操作资源。
最常用的HTTP方法有GET、POST、PUT和DELETE。
GET用于读取资源的数据，POST用于创建新的资源，PUT用于更新已存在的资源，DELETE用于删除资源。
通过使用这些HTTP方法，客户端和服务器之间的通信变得一致和可预测。
此外，RESTful协议使用HTTP状态码来表示请求的处理结果。
HTTP状态码是一种三位数的代码，它表示服务器处理请求后的状态。
常见的状态码有200（成功）、201（已创建）、400（错误的请求）、401（未授权）、404（未找到）和500（服务器内部错误）等。
通过查看状态码，客户端可以了解到请求的处理结果，并根据需要采取相应的操作。
另外，RESTful协议强调资源的自描述性。
资源的表示可以使用各种格式，比如常见的JSON（JavaScript Object Notation）和XML（eXtensible Markup Language）。
客户端可以指定自己希望的表示格式，而服务器可以根据客户端的需求动态生成相应的表示。
这种自描述性的设计能够提高系统的灵活性和可扩展性。
最后，RESTful协议支持无状态的通信。
MyEclipse 8.0+flex 4 plugin+Blazeds配置
需要软件：jdk-6u12-windows-i586-p.exe、apachetomcat.exe、myeclipse-8.0.0-win32.exe、blazeds-turnkey-4.0.0.14931.zip、FlashBuilder_4_Plugin_LS10.exe一、安装jdk按照步骤，选择路径安装，安装成功后，在安装路径下有java文件，包含jdk和jre 两个子文件。
二、JDK环境变量配置的步骤如下：1.我的电脑-->属性-->高级-->环境变量.2.配置用户变量:a.新建JAVA_HOMEC:\Program Files\Java\jdk1.5.0（JDK的安装路径）b.新建 PATH%JAVA_HOME%\bin;c.新建CLASSPATH.;%JAVA_HOME%\lib;3.测试环境变量配置是否成功：开始-->运行--〉CMD键盘敲入：JAVAC -version出现jdk版本信息，而不是出错信息，即表示配置成功！环境变量配置的理解：1. PATH环境变量。
作用是指定命令搜索路径，在i命令行下面执行命令如javac编译ja va程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。
我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java 等工具了。
2. CLASSPATH环境变量。
作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。
我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。
3. JAVA_HOME环境变量。
它指向jdk的安装目录，Eclipse/NetBeans/Tomcat等软件就是通过搜索JAVA_HOME变量来找到并使用安装好的jdk。
restful使用方法
restful使用方法RESTful是一种基于HTTP协议的Web服务架构风格，它强调使用HTTP协议的GET、POST、PUT、DELETE等方法来实现资源的增删改查。
下面介绍RESTful的使用方法。
1. 定义资源在RESTful中，资源是指需要被访问的对象，可以是一篇文章、一张图片、一个用户等等。
首先需要定义资源的URI（Uniform Resource Identifier），即资源的唯一标识符。
例如，文章资源可以定义为/articles/{id}，其中{id}是文章的唯一标识符。
2. 使用HTTP方法RESTful使用HTTP协议的GET、POST、PUT、DELETE等方法来实现资源的增删改查。
具体使用方法如下：- GET：用于获取资源，例如获取一篇文章的信息，可以使用GET方法访问/articles/{id}。
- POST：用于创建资源，例如创建一篇文章，可以使用POST方法访问/articles/，并在请求体中传递文章的信息。
- PUT：用于更新资源，例如更新一篇文章的信息，可以使用PUT方法访问/articles/{id}，并在请求体中传递更新后的文章信息。
- DELETE：用于删除资源，例如删除一篇文章，可以使用DELETE方法访问/articles/{id}。
3. 使用HTTP状态码RESTful使用HTTP状态码来表示请求的结果。
常见的状态码如下：- 200 OK：表示请求成功。
- 201 Created：表示资源创建成功。
- 204 No Content：表示请求成功，但没有返回任何内容。
- 400 Bad Request：表示请求参数有误。
- 401 Unauthorized：表示未授权访问。
- 404 Not Found：表示请求的资源不存在。
- 500 Internal Server Error：表示服务器内部错误。
4. 使用JSON格式RESTful通常使用JSON格式来传递数据。
【SpringFramework】Spring入门教程（三）使用注解配置
【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。
仅仅只是配置的形式不⼀样。
关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。
所以这两种配置⽅式我们都需要掌握。
基于注解配置的⽅式也已经逐渐代替xml配置。
所以我们必须要掌握使⽤注解的⽅式配置Spring。
配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。
本⽂使⽤IDEA进⾏演⽰。
1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。
注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。
如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><!-- 声明扫描包及其⼦包的类，如果发现有组件注解的类，就创建对象并加⼊到容器中去 --><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。
Java RESTful Web Service实战(第2版
读书笔记
粗略看完，覆盖面广，最大的感受是java web写起来非常笨重，人生苦短。
深刻解读JAX-RS的标准和API设计；Jersey的使用要点和实现原理，以及基于REST的Web服务的设计思想和 原则自第1版发行后，Jersey的版本由2.9更新到了2.22.2，此间REST服务得到了更广泛的认可和使用。
搞技术的人，是停不下来的。时而要开疆拓土，学习和研究新的知识点，弥补自己的技术债；时而要运筹帷 幄，将知识点梳理成线，编织成；时而要深耕细作，面对当下要攻坚的业务所对应的知识点，深入研究、反复实 践、勤于思考、勇于交流。
安全性是指外系统对该接口的访问，不会使服务器端资源的状态发生改变；幂等性（idempotence）是指外 系统对同一REST接口的多次访问，得到的资源状态是相同的。
10.1身份认证 10.2资源授权
10.3认证与授权实 现
10.4 JAX-RS2实现
10.5 REST服 务与OAuth2
10.6本章小结
10.1.1基本认证 10.1.2摘要认证 10.1.3表单认证 10.1.4证书认证
10.2.1容器管理权限 10.2.2应用管理权限
10.3.1基本认证与JDBCRealm 10.3.2摘要认证与UserDatabaseRealm 10.3.3表单认证与DataSourceRealm 10.3.4 Form认证和JAASRealm 10.3.5证书认证与UserDatabaseRealm
1.2.1 REST式的Web服务 1.2.2对比RPC风格 1.2.3对比MVC风格
1.3.1 JAX-RS2标准 1.3.2 JAX-RS2的目标 1.3.3非JAX-RS2的目标 1.3.4解读JAX-RS元素
restful的理解
restful的理解REST（Representational State Transfer）表示资源状态转移，它是一种Web服务设计风格。
RESTful定义了一组规则和约束，用于构建基于HTTP协议的Web服务。
RESTful风格的Web服务基于客户端与服务器之间的资源交换。
客户端可以发起请求，获取或操作服务器上的资源。
RESTful Web服务架构是一种轻量级、分散式的技术，可以实现HTTP协议的访问方式下非常高效的数据管理和传输。
其主要特点是，客户端和服务端之间交互时无需记忆状态，从而实现了资源状态的转移和传输。
非常重要的是，RESTful服务端是资源的提供者，而客户端则是资源的使用者。
在RESTful风格中，资源可以是任何事物，例如html页面、文本文件、图片、JSON数据、XML数据等等。
用于表示资源的标识符通常是URI（统一资源标识符）。
RESTful的基本约束：1.客户端与服务端之间的交互是无状态的。
2.资源的使用方式是通过HTTP动词来描述的。
3.资源可以通过URI来表示。
4.资源可以以XML或JSON等方式进行格式化。
5.资源可以包含链接信息以扩展途径。
在RESTful风格中，每个URI表示一个资源，通过HTTP动词来操作资源，例如获取、创建、更新或删除资源。
由于资源可以表示为任何类型的数据，因此可以使用各种格式对资源表示进行格式化。
常用的格式包括XML和JSON。
RESTful服务的另一个特点是通过超媒体来传递状态。
超媒体是指文本和图形元素等可嵌入到文档中的任何内容。
使用超媒体可以将资源之间的关联关系清晰地表达出来，这使得客户端能够发现服务端上的其他资源以及它们之间的关系。
最后，RESTful服务还有一个特点，就是容易扩展。
因为RESTful服务通过URI进行标识，所以可以根据URI创建新的服务端资源，以扩展服务的功能。
此外，使用超媒体可以使得客户端更容易地发现新的资源。
总结：RESTful是一种易于使用和扩展的Web服务框架，它基于客户端和服务端之间的资源交换。
restful的主要原则
restful的主要原则RESTful 是一种软件架构风格，适用于构建分布式系统，并且与 Web 应用程序的开发紧密相关。
下面将详细介绍 RESTful 的主要原则。
1. 客户端-服务器架构：RESTful 倡导将系统划分为客户端和服务器两个独立的组成部分。
客户端负责发送请求并接收响应，而服务器则负责处理请求并发送响应。
这种分离使得客户端和服务器能够独立地进行开发和演化，并且可以在需要时将它们部署到不同的机器上。
2. 无状态：RESTful 架构是无状态的，意味着在客户端和服务器之间的每个请求都是独立的，服务器不会保留任何关于客户端的状态信息。
所有必要的状态都包含在每个请求中，以便服务器可以正确处理请求并发送适当的响应。
3. 统一的接口：RESTful 架构鼓励使用统一的接口来访问和操作资源。
这个接口由一组标准的 HTTP 方法组成，包括 GET、POST、PUT、DELETE等。
每个 HTTP 方法都具有明确的含义和操作，使得客户端和服务器能够协同工作，而无需了解对方的实现细节。
4. 资源导向：RESTful 架构将应用程序中的所有内容都视为资源，每个资源都有一个唯一的标识符（URI）。
客户端通过 URI 来访问和操作资源，而不是直接操作服务器上的函数或对象。
这种资源导向的方法使得客户端和服务器能够通过简单的 HTTP 操作来实现复杂的应用逻辑。
5. 可缓存的：RESTful 架构鼓励对资源的结果进行缓存，以提高性能和减少网络带宽的使用。
响应可以在服务器上设置缓存策略，以便客户端可以在未来的请求中使用缓存的结果。
这种缓存机制可以减少对服务器的请求，提高系统的性能和可伸缩性。
6. 分层系统：RESTful 架构支持分层系统的构建，其中每个层都能够提供特定的功能和服务。
通过将系统划分为多个层次，可以实现系统的可伸缩性、灵活性和可重用性。
每个层级都可以独立地进行开发和演化，并且可以在不影响其他层级的情况下进行更改。
restful interfaces 通俗易懂
restful interfaces 通俗易懂摘要：1.定义RESTful 接口2.RESTful 接口的优势3.RESTful 接口的构建原则4.RESTful 接口的常见应用场景5.如何设计一个RESTful 接口正文：RESTful 接口是一种遵循REST（表述性状态转移）原则的网络接口，它使得客户端与服务器之间的通信变得更加简单、高效。
RESTful 接口具有易于理解和使用的特点，被广泛应用于各种网络应用中。
RESTful 接口的优势主要体现在以下几个方面：1.易于理解和维护：RESTful 接口遵循HTTP 协议，使用标准的HTTP 方法（如GET、POST、PUT、DELETE）来表示操作，使得接口直观易懂，方便开发人员理解和维护。
2.良好的可扩展性：RESTful 接口基于资源（Resource）的概念，可以方便地添加、删除或修改资源，支持应用的扩展。
3.高效的通信：RESTful 接口通过HTTP 协议的缓存机制，可以有效地减少网络传输的数据量，提高通信效率。
构建RESTful 接口时，需要遵循以下原则：1.统一接口：所有资源都通过统一的HTTP 接口进行访问，简化了客户端与服务器之间的通信。
2.资源：将数据和操作封装成资源，用URL 进行标识，方便客户端获取和管理。
3.使用标准HTTP 方法：遵循HTTP 协议的标准方法（如GET、POST、PUT、DELETE）来表示操作，使得接口更加直观。
4.无状态：RESTful 接口尽量保持无状态，以提高服务器性能和通信效率。
RESTful 接口在以下场景中得到了广泛应用：1.网络API：许多网络应用（如社交媒体、在线购物等）都通过RESTful 接口与客户端进行通信，实现数据的获取、更新和管理。
2.微服务：基于RESTful 接口的微服务架构可以更好地实现应用的模块化、解耦和可扩展。
3.跨平台应用：RESTful 接口可以方便地实现跨平台应用的开发，如Web 应用、移动应用等。
restful使用方法
RESTful使用方法什么是RESTful？RESTful，即Representational State Transfer，是一种软件设计风格，用于构建分布式系统。
它基于标准的HTTP方法（GET、POST、PUT、DELETE等）来进行数据处理和操作。
RESTful架构强调使用统一的接口语义和规范，使得不同的系统可以通过HTTP通信进行互操作。
RESTful架构特点RESTful架构具有以下几个特点： 1. 无状态性(Statelessness)：每次HTTP请求都包含足够的信息来理解该请求，不依赖于服务器存储客户端信息。
2.统一接口(Uniform Interface)：采用统一的方式对资源进行操作，包括资源命名、请求和响应格式等。
3.资源导向(Resource-Oriented)：将系统中的所有概念都抽象为资源，每个资源都有一个唯一的URL进行标识。
4.可缓存性(Cachable)：对于相同的请求，服务器可以使用缓存来提高性能。
5.分层系统(Layered System)：中间层可以缓存、负载均衡、安全认证等，提高系统的可伸缩性和安全性。
RESTful API设计规范RESTful API的设计需要遵循一定的规范，以保证系统的可扩展性和易用性。
以下是一些常见的RESTful API设计规范：1. 使用合适的HTTP方法根据不同的操作类型，使用合适的HTTP方法来表示。
常用的HTTP方法有GET、POST、PUT、DELETE等。
2. 使用合适的HTTP状态码在返回结果时，使用合适的HTTP状态码来表示请求的结果。
常见的状态码有200、201、400、404、500等。
3. 使用合适的URL命名URL应该具有清晰的语义，并且反应出资源的层级关系。
例如： - 获取所有用户信息的API：/users - 获取单个用户信息的API：/users/{id}4. 使用合适的请求格式根据请求的内容类型，使用合适的请求格式。
搭建Flex4.1+Spring+Hibernate
搭建Flex+Hibernate+Spring环境1.安装MyEclipse8.62.安装FlashBuilder_4_Plugin_LS10.exe3.FlashBuilder安装的过程中需要绑定MyEclipse8.6的路径（绑定的目录下必须有myeclipse.exe文件和dropins文件夹）4.安装成功后，启动MyEclipse8.6，报错"An internal error occurred during: "InitializingTargetCfg"ng.NullPointerException",解决办法是删掉Genuitec\Common\plugins文件夹下面的一个包：mon.http_3.0.3.v201007291200.jar，然后重启MyEclipse8.6。
但是发现不能创建Web工程，所以我就把这个包又加到了plugins文件夹下面。
就没报错了。
（如果MyEclipse8.5中没有Tomcat服务器，就要安装一个Tomcat 插件，方法如下：将com.sysdeo.eclipse.tomcat_3.2.1文件夹放到D:\programfiles\Genuitec\Common\plugins，打开D:\program files\Genuitec\MyEclipse8.5\configuration\org.eclipse.equinox.simpleconfigurator\文件，在最后加上com.sysdeo.eclipse.tomcat,3.2.1,file:/D:/programfiles/Genuitec/Common/plugins/com.sysdeo.eclipse.tomcat_3.2.1/,4,false重启MyEclipse8.5.window --> preferences --> Tomcat 配置一些参数,OK!）5.新建web项目HCS6.添加bleazeds支持找到已解压的bleazeds 文件夹，进入到：blazeds\WEB-INF复制flex和lib两个文件夹到HCS下的webRoot/WEB-INF目录下7.在web.xml文件中添加代码：<!-- Flex配置 --><!-- Http Flex Session attribute and binding listener support --> <listener><listener-class>flex.messaging.HttpFlexSession</listener-class> </listener><!-- MessageBroker Servlet --><servlet><servlet-name>MessageBrokerServlet</servlet-name><!--<display-name>MessageBrokerServlet</display-name>--><servlet-class>flex.messaging.MessageBrokerServlet</servlet-class ><init-param><param-name>services.configuration.file</param-name><param-value>/WEB-INF/flex/services-config.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>MessageBrokerServlet</servlet-name><url-pattern>/messagebroker/*</url-pattern></servlet-mapping>8.将web工程添加到tomcat中启动tomcat9.添加Flex工程右键HCS，选择：添加/更改项目类型—>添加Flex项目类型注：服务技术选择如下10.点Next，如下配置11.点击Finish，配置Flex 项目属性在Flex视图下,右键properties打开项目属性设置对话框打开项目属性设置对话框将”生成HTML包装器文件”的钩钩去掉，点击Apply，在将此钩钩钩上点击OK，工程下面就会出现http-template文件夹13,这是http-template文件夹下面的index.template.html文件报错，打开此文件，删除这行注释<!--For version detection,set to min.required Flash Player version, or 0(or 0.0.0),for no version detection.-->保存就没错了13. 到了这个时候基本上已经搭建好Flex+bleazeds的web环境,现在来测试一下1.)新建一个包：er.web2.) 在包中新一个类：HelloWorld，作用flex的一个远程对象,HelloWorld中的代码如下package er.web;public class HelloWorld {public String sayHelloTo(String name){return"Hello "+name;}}3.)在HCS/WebRoot/WEB-INF/flex/remoting-config.xml注册这个远程对象<destination id="Hello"><properties><source>er.web.HelloWorld</source></properties></destination>4.)在src/HCS.mxml 中添加以下代码：<?xml version="1.0" encoding="utf-8"?><mx:Application xmlns:mx="/2006/mxml"layout="absolute"><mx:Script><![CDATA[private functionremotingSayHello(event:Event):void{var iname:String=tiName.text;say.sayHelloTo(iname);}]]></mx:Script><mx:RemoteObject id="say" destination="Hello"></mx:RemoteObject><mx:Button x="335" y="80" label=" Click"click="remotingSayHello(event);"/><mx:TextInput x="159" y="80" id="tiName"/><mx:Label x="109" y="82" text="name:"/><mx:Label text="{stResult}" x="44"y="162" width="448" height="71" id="lblView" color="#FCEE09"fontSize="20" fontWeight="bold" textDecoration="underline"fontStyle="normal"/></mx:Application>5.)启动tomcat,等tomcat启动好后，右键单击HCS.mxml，选中Run As—>Web应用程序，效果如下到了这一步，flex+bleazeds已经完成14.添加Spring框架，在MyEclipse Java Enterprise视图下的步骤如下：点击HCS工程—>MyEclipse—>Add Spring Capabilities点击Next点击Finish点击Keep Existing15. 添加mon，添加SpringFactory.java(网上的)package mon;import org.springframework.context.ApplicationContext;import org.springframework.web.context.support.WebApplicationContextUtils;import org.springframework.beans.BeansException;import org.springframework.beans.factory.NoSuchBeanDefinitionException;import flex.messaging.FactoryInstance;import flex.messaging.FlexFactory;import flex.messaging.config.ConfigMap;import flex.messaging.services.ServiceException;/*** This interface is implemented by factory components which provide* instances to the flex messaging framework. To configure flex data services* to use this factory, add the following lines to your services-config.xml* file (located in the WEB-INF/flex directory of your web application).** <factories>* <factory id="spring" class="flex.samples.factories.SpringFactory" />* </factories>** You also must configure the web application to use spring and must copy the spring.jar* file into your WEB-INF/lib directory. To configure your app server to use spring,* you add the following lines to your WEB-INF/web.xml file:** <context-param>* <param-name>contextConfigLocation</param-name>* <param-value>/WEB-INF/applicationContext.xml</param-value>* </context-param>** <listener>*<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class >* </listener>** Then you put your spring bean configuration in WEB-INF/applicationContext.xml (as per the * line above). For example:** <?xml version="1.0" encoding="UTF-8"?>* <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd">** <beans>* <bean name="weatherBean" class="dev.weather.WeatherService" singleton="true"/> * </beans>** Now you are ready to define a destination in flex that maps to this existing service.* To do this you'd add this to your WEB-INF/flex/remoting-config.xml:** <destination id="WeatherService">* <properties>* <factory>spring</factory>* <source>weatherBean</source>* </properties>* </destination>** @author Jeff Vroom*/public class SpringFactory implements FlexFactory{private static final String SOURCE = "source";/*** This method can be used to initialize the factory itself. It is called with configuration * parameters from the factory tag which defines the id of the factory.*/public void initialize(String id, ConfigMap configMap) {}/*** This method is called when we initialize the definition of an instance* which will be looked up by this factory. It should validate that* the properties supplied are valid to define an instance.* Any valid properties used for this configuration must be accessed to* avoid warnings about unused configuration elements. If your factory* is only used for application scoped components, this method can simply* return a factory instance which delegates the creation of the component* to the FactoryInstance's lookup method.*/public FactoryInstance createFactoryInstance(String id, ConfigMap properties){SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties);instance.setSource(properties.getPropertyAsString(SOURCE, instance.getId()));return instance;} // end method createFactoryInstance()/*** Returns the instance specified by the source* and properties arguments. For the factory, this may mean* constructing a new instance, optionally registering it in some other* name space such as the session or JNDI, and then returning it* or it may mean creating a new instance and returning it.* This method is called for each request to operate on the* given item by the system so it should be relatively efficient.* <p>* If your factory does not support the scope property, it* report an error if scope is supplied in the properties* for this instance.*/public Object lookup(FactoryInstance inst){SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;return factoryInstance.lookup();}static class SpringFactoryInstance extends FactoryInstance{SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties){super(factory, id, properties);}public String toString(){return "SpringFactory instance for id=" + getId() + " source=" + getSource() + " scope=" + getScope();}public Object lookup(){ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(flex.messaging.FlexContext.getServletC onfig().getServletContext());String beanName = getSource();try{return appContext.getBean(beanName);}catch (NoSuchBeanDefinitionException nexc){ServiceException e = new ServiceException();String msg = "Spring service named '" + beanName + "' does not exist.";e.setMessage(msg);e.setRootCause(nexc);e.setDetails(msg);e.setCode("Server.Processing");throw e;}catch (BeansException bexc){ServiceException e = new ServiceException();String msg = "Unable to create Spring service named '" + beanName + "' ";e.setMessage(msg);e.setRootCause(bexc);e.setDetails(msg);e.setCode("Server.Processing");throw e;}}}}16. 在WEB-INF/flex中的services-config.xml中注册SpringFactory工厂<factories><factory id="spring"class="mon.SpringFactory"/></factories>17.在WEB-INF文件夹下建立conf文件夹，将applicationContext.xml 移入此中，在WEB-INF/web.xml中加入对spring的支持<!-- Spring配置 --><!-- Backend configuration --><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/conf/*/spring-*.xml,/WEB-INF/conf/applicationContext.xml</param-value></context-param><servlet><servlet-name>SpringContextServlet</servlet-name><servlet-class>org.springframework.web.context.ContextLoaderServlet </servlet-class><load-on-startup>1</load-on-startup></servlet><servlet><servlet-name>SpringLog4jConfigServlet</servlet-name> <servlet-class>org.springframework.web.util.Log4jConfigServlet </servlet-class></servlet><servlet><servlet-name>web</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class></servlet>17．添加hibernate1).创建表create table hcs_user(user_id int primary key not null,user_name varchar2(30),real_name varchar2(20),password varchar2(20),sex varchar2(3),birthday varchar2(30),email varchar2(40),address varchar2(50),telephone varchar2(20),qq varchar2(15),authority varchar2(50),remarks varchar2(50));2).切换到MyEclipse Hibernate视图添加数据源New Database Connection Dirver点击Next,点击Finish3.)加进hibernate框架，在MyEclipse Java Enterprise视图下的步骤如下：点击HCS工程—>MyEclipse—>Add Hibernate Capabilities18.添加包，结构如下：19.删除asm-2.2.3.jar20.利用myeclipse自动生成User.java,User.hbm.xml,UserDAO右击表名，选中Hibernate Reverse Engineering,21.把UserDAO放到er.dao.impl下22.修改applicationContext.xml<bean id="userDAO"class="erDAO"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>23.在er.service.impl添加service类，起名IUserServiceImplpackage er.service.impl;import erDAO;import er;public class IUserServiceImpl {private UserDAO userDAO;public void setUserDAO(UserDAO userDAO) {erDAO = userDAO;}/*通过ID搜索返回一个User对象* @param id 需要查找的用户ID* @return User对象**/public User getUser(java.math.BigDecimal id){return userDAO.findById(id);}}24. 修改HellWorld.java文件package er.web;import java.math.BigDecimal;import er;import er.service.impl.IUserServiceImpl;public class HelloWorld {private IUserServiceImpl userService;/** 该方法通过用户ID返回用户名* @param id 用记ID* @return String “你好”+用户名*/public String sayHelloTo(String id){User user = new User();user = userService.getUser(BigDecimal.valueOf(Long.parseLong(id)));return "Hello "+user.getUserName();}public void setUserService(IUserServiceImpl userService) { erService = userService;}}25.在WEB-INF的conf文件夹下面添加如下文件dbconfig.properties文件通过配置文件设置访问Oracle数据库的参数代码如下#Database Settings#db urlDATABASE_URL=localhost#db nameDATABASE_NAME=xe#db login user nameDATABASE_USERNAME=HCS#db login user passwordDATABASE_PASSWORD=123#db portDATABASE_PORT=1520driverClassName=oracle.jdbc.driver.OracleDriverlog4j.properties文件日志输出代码如下：#log4j.rootLogger=INFO,A1,R#log4j.rootLogger=DEBUG,A1,Rlog4j.rootLogger=DEBUG,A1log4j.appender.A1=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%-d{yyyy-MM-ddHH:mm:ss,SSS}[%c]-[%p]%m%nlog4j.appender.R=org.apache.log4j.RollingFileAppenderlog4j.appender.R.File=D:/SSH.txtlog4j.appender.R.MaxFileSize=5120KBlog4j.appender.R.MaxBackupIndex=1yout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-ddHH\:mm\:ss,SSS}[%t][%c][%p]-%m%n在web.xml文件中添加<!--log4j config start!--><context-param><param-name>log4jConfigLocation</param-name><param-value>/WEB-INF/conf/log4j.properties</param-value> </context-param><context-param><param-name>log4jRefreshInterval</param-name><param-value>60000</param-value></context-param><listener><listener-class>org.springframework.web.util.Log4jConfigListener </listener-class></listener><!--log4j end .-->日志输出添加user文件夹里面添加如下文件spring-dao.xml代码如下：<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="userDAO"class="erDAO"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean></beans>spring-service.xml代码如下：<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="userService"class="er.service.impl.IUserServiceImpl"> <property name="userDAO"><ref bean="userDAO"/></property></bean></beans>spring-web文件代码如下：<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="helloWorld"class="er.web.HelloWorld"><property name="userService"><ref bean="userService"/></property></bean></beans>26.修改applicationContext.xml代码如下：<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.0.x sd"><bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPla ceholderConfigurer"><property name="locations"><list><value>/WEB-INF/conf/dbconfig.properties</value> </list></property></bean><!-- 配置数据源 --><bean id="dataSource"class="mons.dbcp.BasicDataSource"><!-- 驱动类 --><property name="driverClassName"><value>${driverClassName}</value></property><!-- 数据库连接地址 --><property name="url"><value>jdbc:oracle:thin:@${DATABASE_URL}:${DATABASE_PORT}:$ {DATABASE_NAME}</value></property><property name="username"><value>${DATABASE_USERNAME}</value></property><property name="password"><value>${DATABASE_PASSWORD}</value></property></bean><!-- hibernate Session工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFacto ryBean"><property name="dataSource"><ref bean="dataSource"/></property><!-- 下面是hibernate的属性设置 --><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop><prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop><prop key="hibernate.autoReconnect">true</prop><!-- 显示输出SQL --><prop key="hibernate.show_sql">true</prop><!-- 输入SQL时进行格式化 --><prop key="hibernate.format_sql">true</prop></props></property><property name="mappingResources"><list><value>com/zuohd/hcs/user/model/User.hbm.xml</value></list></property></bean></beans>27.修改：WEB－INF/flex/remoting-config.xml<destination id="Hello"><properties><factory>spring</factory><source>helloWorld</source></properties></destination>28.启动tomcat，运行页面，效果：。
JavaRESTful框架详细介绍
JavaRESTful框架详细介绍Java RESTful框架详细介绍REST (Representational State Transfer) 是一种通过HTTP协议传输数据的软件架构风格。
它利用URL来定位资源，使用HTTP方法（GET、POST、PUT、DELETE等）对资源进行操作。
Java RESTful框架为开发人员提供了构建符合REST原则的Web服务的工具和技术。
本文将介绍几个常见的Java RESTful框架，并讨论它们的特点和应用。
一、Spring BootSpring Boot是一个用于快速构建Java应用程序的开源框架。
它基于Spring框架，并集成了多种Web开发的相关组件，包括Spring MVC用于构建RESTful服务。
Spring MVC提供了强大的路由和请求处理功能，可以方便地编写符合REST风格的API。
通过使用Spring Boot，我们可以轻松快速地构建并运行RESTful服务。
二、JerseyJersey是一个遵循JAX-RS（Java API for RESTful Web Services）标准的开源框架。
它实现了JAX-RS的规范，并提供了一些扩展功能。
Jersey在Java开发人员中非常受欢迎，因为它提供了丰富而灵活的特性，允许开发人员根据需求轻松构建RESTful服务。
另外，Jersey的文档和示例丰富，有助于新手快速上手。
三、RestletRestlet是一个用于构建RESTful Web服务的开源框架。
它支持多种Java环境，包括标准Java、Android、GAE等。
Restlet提供了一套简单易用的API，支持多种HTTP方法和格式，如GET、POST、JSON、XML等。
通过Restlet，开发人员可以轻松地定义路由、处理请求和响应，并实现完整的RESTful服务。
四、CXFApache CXF是一个开源的、全功能的Web服务框架。
restful java 例子
restful java 例子
下面是一个简单的基于Java的RESTful服务示例代码：
```java
import java.util.Date;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/novel")
public class NovelResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getNovel() {
return "现在的时间是：" + new Date();
}
}
```
上述代码定义了一个`NovelResource`类，它使用`@Path`注解指定了资源的路径为`/novel`。
`@GET`注解表示该资源将以GET方式访问，`@Produces`注解指定了返回的媒体类型为`MediaType.TEXT_PLAIN`，表示返回的数据为文本类型。
在`getNovel`方法中，返回了一个简单的文本字符串，其中包含当前时间。
这只是一个简单的示例，实际的RESTful服务可能会涉及到更多的处理和交互。
你可以根据具体需求扩展和修改这个示例代码。
restfull理解
restfull理解
RESTful 是一种架构风格，用于设计网络应用程序的 API。
它
的全称是 Representational State Transfer（表征状态转移），是
一种简化的、轻量级的通信协议，主要基于 HTTP 协议进行数据通信。
RESTful API 遵循一些规范和约定，以提供简单、可扩展、可
维护和高效的 Web 服务。
其核心原则包括：
1. 基于统一资源的访问：每个资源都有一个唯一的标识符（URL），使用HTTP 方法（GET、POST、PUT、DELETE）对资源进行操作。
2. 无状态设计：服务端不会保存客户端请求的状态信息，每个请求均独立处理，客户端需提供所有必要的信息。
3. 使用标准的 HTTP 方法和状态码：GET 用于获取资源，POST 用于创建资源，PUT 用于更新资源，DELETE 用于删除
资源。
服务端应返回合适的状态码，如200 OK、201 Created、404 Not Found 等。
4. 使用可扩展的媒体类型：RESTful API 可返回多种媒体类型，如 JSON、XML、HTML。
客户端通过设置合适的 Accept 头
部来指定返回的数据格式。
5. 资源的超媒体引用：服务端通过返回的响应中嵌入链接，使得客户端能够自动探索和访问相关资源。
通过 RESTful API，客户端可以通过简单的 HTTP 请求和响应进行与服务端的通信。
这种设计风格使得不同平台的应用程序可以方便地进行集成和交互。
同时，RESTful API 的规范性和可扩展性也使得系统的开发和维护更加简单和高效。
interfaceservice注解
interfaceservice注解下载温馨提示：该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by the editor. I hope that after you download them, they can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, our shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!接口是程序设计中非常重要的概念，通过接口可以实现不同模块之间的解耦合，提高代码的灵活性和可维护性。
idea restfultool参数使用 -回复
idea restfultool参数使用-回复什么是RESTful 工具的参数？在REST 架构中，RESTful 工具的参数是指在调用RESTful 接口时传递给服务器的数据。
这些参数可以用于向服务器传递用户信息、请求数据、或者控制接口的行为。
RESTful 工具的参数一般以键值对（key-value）的形式出现，常见的形式为URL 参数、请求体参数和请求头参数。
1. URL 参数：URL 参数是直接附加在URL 中的参数，一般以问号（?）开始。
它们以键值对的形式出现，并且多个参数之间用ampersand 符号（&）分隔。
例如，一个获取用户信息的GET 请求可以被定义为`/users?userId=123&token=abc`，其中`userId` 和`token` 就是两个URL 参数，分别对应用户的标识和身份验证令牌。
2. 请求体参数：请求体参数是在RESTful 接口的请求体中传递的参数。
通常，这种参数出现在POST、PUT 和PATCH 请求中，用于传递需要改造服务器资源的数据。
请求体参数可以通过不同的格式来编码，最常见的有JSON、XML 和表单数据等。
例如，一个创建新用户的POST 请求可以包含一个JSON 请求体，其中包含用户信息的键值对。
3. 请求头参数：请求头参数是附加在HTTP 请求头部的参数，用于提供一些额外的信息给服务器。
它们以键值对的形式存储在请求头中，一般以`Header-Name: Value` 的格式呈现。
比如，常见的请求头参数之一是`Content-Type`，用于指示请求体的数据格式。
如何使用RESTful 工具的参数？使用RESTful 工具的参数可以根据具体需求而灵活变化，但一般遵循以下几个步骤：1. 确定接口需求：首先，需要明确调用的RESTful 接口的需求。
这包括请求数据的类型、传递给服务器的特定参数以及期望获得的响应。
可以通过查阅接口文档或者与接口开发者沟通来获得这些信息。
milvus restful说明
milvus restful说明
Milvus是一个开源的向量相似度搜索引擎，它提供了RESTful API来进行向量检索。
RESTful API是一种基于HTTP协议的API设
计风格，它使用标准的HTTP方法（如GET、POST、PUT、DELETE）
来实现对资源的操作。
在Milvus中，RESTful API提供了一种简单
而灵活的方式来与Milvus进行交互，使用户能够通过HTTP请求进
行向量检索和管理Milvus的集合、向量等资源。
通过Milvus的RESTful API，用户可以实现向量的插入、删除、查询等操作。
用户可以使用POST方法向Milvus中插入向量数据，
使用DELETE方法删除指定的向量数据，使用GET方法进行向量的相
似度搜索。
此外，用户还可以使用PUT方法更新向量数据或者修改Milvus的配置信息。
另外，Milvus的RESTful API还提供了对集合（collection）
的管理功能，用户可以使用GET方法获取集合的信息，使用POST方
法创建新的集合，使用DELETE方法删除指定的集合，使用PUT方法
更新集合的配置信息等。
总的来说，Milvus的RESTful API为用户提供了一种方便、灵
活的方式来与Milvus进行交互，使用户能够通过简单的HTTP请求实现向量检索和管理Milvus的各种资源。
这种设计使得Milvus可以很好地集成到各种应用程序中，为用户提供高效的向量相似度搜索功能。
restful集成方式简述
restful集成方式简述RESTful（Representational State Transfer）是一种用于构建Web 服务的设计风格和架构原则。
它基于HTTP协议，通过标准的HTTP方法（GET、POST、PUT、DELETE等）来操作资源，使用URL来定位资源，并使用简单的数据格式（如JSON、XML）进行数据交换。
以下是RESTful集成方式的简述：1.定义资源和URL结构：首先，需要明确定义需要暴露为Web服务的资源，并为每个资源定义一个唯一的URL。
URL的结构应该符合RESTful的规范，简洁、清晰和可读性强。
2.使用HTTP方法操作资源：RESTful架构中，不同的HTTP方法对应不同的操作。
例如，使用GET方法获取资源，使用POST方法创建资源，使用PUT方法更新资源，使用DELETE方法删除资源。
根据操作类型，对资源的URL进行相应的HTTP请求。
3.使用HTTP状态码传递结果：RESTful架构使用HTTP状态码来反映请求的结果。
常见的状态码包括200（OK，请求成功）、201（Created，资源创建成功）、400（Bad Request，请求错误）、404（Not Found，资源未找到）等。
使用适当的状态码能够提供对客户端有意义的反馈信息。
4.使用合适的数据格式进行数据交换：RESTful集成使用多种数据格式进行数据交换，最常见的是JSON和XML。
JSON格式简洁轻巧，易于读写和解析，而XML格式具有更丰富的数据结构和语义。
5.身份认证和授权：在RESTful集成中，可以使用标准的身份认证机制（如基本认证、令牌认证）来保护资源的安全性。
同时，通过授权机制（如OAuth）来限制对资源的访问权限。
6.使用HATEOAS（Hypermedia as the Engine of ApplicationState）：HATEOAS是RESTful架构的一个重要原则，它表示应用的状态信息（如可用操作、可访问资源）应该通过资源本身的链接提供。
feign常用注解
Feign是一个基于Java的HTTP客户端开发工具，它能够帮助我们快速地开发出RESTful风格的微服务。
在使用Feign的过程中，注解是非常重要的一部分，下面我们将详细介绍Feign 常用注解。
一、@FeignClient注解@FeignClient是Feign的核心注解，它用于声明一个Feign客户端。
该注解有三个属性值：1. value：用于指定Feign客户端的名称，可以是服务的名称或URL。
如果服务的名称和URL 都没有指定，则默认使用接口的全限定名作为服务名称。
2. url：用于指定Feign客户端的URL地址。
当我们使用该属性时，value属性将被忽略。
3. fallback：用于指定Feign客户端的回退实现类。
当服务出现故障时，将会调用该类中的方法。
这里举个例子：```@FeignClient(value = "order-service", fallback = OrderServiceFallback.class)public interface OrderServiceClient {@GetMapping("/orders/{orderId}")OrderDTO getOrderById(@PathVariable("orderId") Long orderId);}```二、@RequestMapping注解@FeignClient注解只是声明了一个Feign客户端，我们还需要使用@RequestMapping注解来声明具体的请求路径。
该注解有以下属性值：1. method：用于指定请求的方法类型，如GET、POST等。
2. value：用于指定请求的路径。
3. consumes：用于指定请求的Content-Type。
4. produces：用于指定响应的Content-Type。
下面是一个使用@RequestMapping注解的例子：```@FeignClient(value = "order-service")public interface OrderServiceClient {@RequestMapping(method = RequestMethod.GET, value = "/orders/{orderId}", consumes = "application/json")OrderDTO getOrderById(@PathVariable("orderId") Long orderId);}```三、@PathVariable注解@PathVariable注解用于将请求路径中的参数绑定到方法参数上。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于restful注解(spring4.0.2整合flex+blazeds＋spring-mvc)<一>参考官网：1./blazeds/1/blazeds_devguide/2.http://docs.spring.io/spring-flex/docs/1.5.2.RELEASE/reference/html/1）下载blazeds（turnkey4.0.x版本）网址：/adobe/blazeds/wiki/Home/2）先创建maven工程，然后进入blazeds目录/tomcat/webapps/blazeds/WEB-INF/flex 连flex目录拷贝到src/main/resource目录下(也可以直接拷贝文件)如图：3）核心flex相关jar包下载spring-flex-core-1.5.2.RELEASE.jarblazeds-core-4.0.0.14931.jarblazeds-common-4.0.0.14931.jarblazeds-proxy-4.0.0.14931.jarblazeds-remoting-4.0.0.14931.jar其中spring-flex-core-1.5.2.RELEASE.jar可以从远程maven中心仓库下载，而blazeds 的jar在中心仓库版本有误，如图：spring容器启动时spring-flex-core-1.5.2依赖的是blazeds的4.0.0.14931版本，而maven中心仓库并无此jar包，因此以上四个包需手工打入本地maven仓库，打入命令进入blazeds目录/resources/lib下执行以下maven命令mvn install:install-file -Dpackaging=jar -DgroupId=com.adobe.blazeds -Dversion =4.0.0.14931 -DartifactId=blazeds-common -Dfile=flex-messaging-common.jarmvn install:install-file -Dpackaging=jar -DgroupId=com.adobe.blazeds -Dversion =4.0.0.14931 -DartifactId=blazeds-core -Dfile=flex-messaging-core.jarmvn install:install-file -Dpackaging=jar -DgroupId=com.adobe.blazeds -Dversion =4.0.0.14931 -DartifactId=blazeds-opt -Dfile=flex-messaging-opt.jarmvn install:install-file -Dpackaging=jar -DgroupId=com.adobe.blazeds -Dversion =4.0.0.14931 -DartifactId=blazeds-proxy -Dfile=flex-messaging-proxy.jarmvn install:install-file -Dpackaging=jar -DgroupId=com.adobe.blazeds -Dversion =4.0.0.14931 -DartifactId=blazeds-remoting -Dfile=flex-messaging-remoting.jar 至此在工程中即可引入相关jar包.4) 配置flex/services-config.xml文件红色为修改后内容channel对于flex来讲，相当于一个通信管道，在flex客户端端表现为endpoint="下面红色字体中endpoint.url属性"1<?xml version="1.0" encoding="UTF-8"?>2<services-config>34 <services>5 <service-include file-path="remoting-config.xml" />6 <service-include file-path="proxy-config.xml" />7 <service-include file-path="messaging-config.xml" />8 </services>910 <security>11 <login-command class="flex.messaging.security.TomcatLoginCommand " server="Tomcat"/>12 <!-- Uncomment the correct app server13 <login-command class="flex.messaging.security.TomcatLoginCommand " server="JBoss">14 <login-command class="flex.messaging.security.JRunLoginCommand" s erver="JRun"/>15 <login-command class="flex.messaging.security.WeblogicLoginComman d" server="Weblogic"/>16 <login-command class="flex.messaging.security.WebSphereLoginComm and" server="WebSphere"/>17 -->1819 <!--20 <security-constraint id="basic-read-access">21 <auth-method>Basic</auth-method>22 <roles>23 <role>guests</role>24 <role>accountants</role>25 <role>employees</role>26 <role>managers</role>27 </roles>28 </security-constraint>29 -->30 </security>3132 <channels>3334 <channel-definition id="my-amf" class="mx.messaging.channels.AMFCh annel">35<endpoint url="http://localhost:8080/iloveu/messagebroker/amf"cla ss="flex.messaging.endpoints.AMFEndpoint"/>36 <properties>37 <polling-enabled>false</polling-enabled>38 </properties>39 </channel-definition>4041 <channel-definition id="my-secure-amf" class="mx.messaging.channels. SecureAMFChannel">42<endpoint url="https://localhost:8080/iloveu/messagebroker/amfsec ure"class="flex.messaging.endpoints.SecureAMFEndpoint"/>43 <properties>44 <add-no-cache-headers>false</add-no-cache-headers>45 </properties>46 </channel-definition>4748 <channel-definition id="my-polling-amf" class="mx.messaging.channels. AMFChannel">49<endpoint url="http://localhost:8080/iloveu/messagebroker/amfpolli ng"class="flex.messaging.endpoints.AMFEndpoint"/>50 <properties>51 <polling-enabled>true</polling-enabled>52 <polling-interval-seconds>4</polling-interval-seconds>53 </properties>54 </channel-definition>5556 <!--57 <channel-definition id="my-http" class="mx.messaging.channels.HTTPC hannel">58 <endpoint url="http://{}:{server.port}/{context.root}/ messagebroker/http" class="flex.messaging.endpoints.HTTPEndpoint"/>59 </channel-definition>6061 <channel-definition id="my-secure-http" class="mx.messaging.channels. SecureHTTPChannel">62 <endpoint url="https://{}:{server.port}/{context.root}/ messagebroker/httpsecure" class="flex.messaging.endpoints.SecureHTTPEndpoin t"/>63 <properties>64 <add-no-cache-headers>false</add-no-cache-headers>65 </properties>66 </channel-definition>67 -->68 </channels>6970 <logging>71 <target class="flex.messaging.log.ConsoleT arget" level="Error">72 <properties>73 <prefix>[BlazeDS] </prefix>74 <includeDate>false</includeDate>75 <includeTime>false</includeTime>76 <includeLevel>false</includeLevel>77 <includeCategory>false</includeCategory>78 </properties>79 <filters>80 <pattern>Endpoint.*</pattern>81 <pattern>Service.*</pattern>82 <pattern>Configuration</pattern>83 </filters>84 </target>85 </logging>8687 <system>88 <redeploy>89 <enabled>false</enabled>90 <!--91 <watch-interval>20</watch-interval>92 <watch-file>{context.root}/WEB-INF/flex/services-config.xml</watc h-file>93 <watch-file>{context.root}/WEB-INF/flex/proxy-config.xml</watch-f ile>94 <watch-file>{context.root}/WEB-INF/flex/remoting-config.xml</wat ch-file>95 <watch-file>{context.root}/WEB-INF/flex/messaging-config.xml</wa tch-file>96 <watch-file>{context.root}/WEB-INF/flex/data-management-config.x ml</watch-file>97 <touch-file>{context.root}/WEB-INF/web.xml</touch-file>98 -->99 </redeploy>100 </system>101102</services-config>1035）搭建spring－mvc框架web.xml1 <context-param>2 <param-name>contextConfigLocation</param-name>3 <param-value>4 classpath:applicationContext.xml5 </param-value>6 </context-param>78 <listener>9 <listener-class>10 org.springframework.web.context.ContextLoaderListener11 </listener-class>12 </listener>1314 <servlet>15 <servlet-name>spring-mvc</servlet-name>16 <servlet-class>17 org.springframework.web.servlet.DispatcherServlet18 </servlet-class>19 <init-param>20 <param-name>contextConfigLocation</param-name>21 <param-value>classpath:spring-mvc-servlet.xml</param-value>22 </init-param>23 <load-on-startup>1</load-on-startup>24 </servlet>2526 <servlet-mapping>27 <servlet-name>spring-mvc</servlet-name>28 <url-pattern>*.htm</url-pattern>29 </servlet-mapping>3031 <servlet>32 <servlet-name>flex</servlet-name>33 <servlet-class>org.springframework.web.servlet.DispatcherServlet</ser vlet-class>34 <init-param>35 <param-name>contextConfigLocation</param-name>36 <param-value>classpath:flex-servlet.xml</param-value>37 </init-param>38 <load-on-startup>1</load-on-startup>39 </servlet>4041 <servlet-mapping>42 <servlet-name>flex</servlet-name>43 <url-pattern>/messagebroker/amf/*</url-pattern>44 </servlet-mapping>因为基于maven工程，配置文件都在src/main/resources目录下，flex和spring-mvc子容器单独配置classpath，否则会自动查找/WEB-INF/<servlet-name>-servlet.xml文件。