java後台的值傳到前台_java怎樣在後台獲取前台jsp頁面文本框的value值

① 如何實現後台向前台傳數據

這兩天正在研究如何讓後天主動向前台展現數據，只要後台有數據上傳的時候就向前台上傳(因為公司有個項目，硬體設備會不斷的上傳數據，服務端將接收到的數據向前台展示)。在網上查了一下，下面將介紹一下其中的兩種解決辦法
一、WebSocket
WebSocket 是web客戶端和伺服器之間新的通訊方式，依然架構在HTTP協議之上。使用WebSocket連接， web應用程序可以執行實時的交互，而不是以前的poll方式。
WebSocket是HTML5開始提供的一種在單個 TCP 連接上進行全雙工通訊的協議，可以用來創建快速的更大規模的健壯的高性能實時的web應用程序。WebSocket通信協議於2011年被IETF定為標准RFC 6455，WebSocketAPI被W3C定為標准。
在WebSocket API中，瀏覽器和伺服器只需要做一個握手的動作，然後，瀏覽器和伺服器之間就形成了一條快速通道。兩者之間就直接可以數據互相傳送。

什麼是WebSocket?
一個WebSocket是通過一個獨立的TCP連接實現的、非同步的、雙向的、全雙工的消息傳遞實現機制。WebSockets不是一個HTTP連接，卻使用HTTP來引導一個WebSocket連接。一個全雙工的系統允許同時進行雙向的通訊。陸地線路電話是一個全雙工設施的例子，因為它們允許兩個通話者同時講話並被對方聽到。最初WebSocket被提議作為HTML5規范的一部分，HTML5承諾給現代的互動式的web應用帶來開發上的便利和網路效率，但是隨後WebSocket被移到一個僅用來存放WebSockets規范的獨立的標准文檔里。它包含兩件事情 -- WebSocket協議規范，即2011年12月發布的RFC 6455，和WebSocket javaScript API。
WebSocket協議利用HTTP 升級頭信息來把一個HTTP連接升級為一個WebSocket連接。HTML5 WebSockets 解決了許多導致HTTP不適合於實時應用的問題，並且它通過避免復雜的工作方式使得應用結構很簡單。
最新的瀏覽器都支持WebSockets，
WebSocket是如何工作的?
每一個WebSocket連接的生命都是從一個HTTP請求開始的。HTTP請求跟其他請求很類似，除了它擁有一個Upgrade頭信息。Upgrade頭信息表示一個客戶端希望把連接升級為不同的協議。對WebSockets來說，它希望升級為WebSocket協議。當客戶端和伺服器通過底層連接第一次握手時，WebSocket連接通過把HTTP協議轉換升級為WebSockets協議而得以建立。一旦WebSocket連接成功建立，消息就可以在客戶端和伺服器之間進行雙向發送
WebSockets比其它工作方式比如輪詢更有效也更高效。因為它需要更少的帶寬並且降低了延時。
WebSockets簡化了實時應用的結構體系。
WebSockets在點到點發送消息時不需要頭信息。這顯著的降低了帶寬。
一些可能的WebSockets使用案例有:
聊天應用
多人游戲
股票交易和金融應用
文檔合作編輯
社交應用
jsR 356，WebSocket的Java API，規定了開發者把WebSockets 整合進他們的應用時可以使用的Java API — 包括伺服器端和Java客戶端。JSR 356是Java EE 7標准中的一部分。這意味著所有Java EE 7兼容的應用伺服器都將有一個遵守JSR 356標準的WebSocket協議的實現。開發者也可以在Java EE 7應用伺服器之外使用JSR 356。目前Apache Tomcat 8提供了JSR 356 API的WebSocket支持。 Jboss Wildfly 8 (原JBoss Application Server)也支持JSR 356.
一個Java客戶端可以使用兼容JSR 356的客戶端實現，來連接到WebSocket伺服器。對web客戶端來說，開發者可以使用WebSocket JavaScript API來和WebSocket伺服器進行通訊。WebSocket客戶端和WebSocket伺服器之間的區別，僅在於兩者之間是通過什麼方式連接起來的。一個WebSocket客戶端是一個WebSocket終端，它初始化了一個到對方的連接。一個WebSocket伺服器也是一個WebSocket終端，它被發布出去並且等待來自對方的連接。在客戶端和伺服器端都有回調監聽方法 -- onOpen , onMessage , onError, onClose。
怎麼創建你的第一個WebSocket應用呢？基本上我們還是會使用Javascript API編寫WebSocket客戶端，在伺服器端，本文使用JSR 356規范定義的通用模式和技術處理WebSocket的通訊。
下面看一個簡單的例子，演示了如果使用JavaScript WebSocket客戶端與運行在Wildfly 8伺服器通信.
客戶端代碼

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

<html>
<head>
<meta http-equiv="content-type"content="text/html; charset=ISO-8859-1">
</head>

<body>
<meta charset="utf-8">
<title>HelloWorld Web sockets</title>
<script language="javascript"type="text/javascript">
var wsUri = getRootUri() + "/websocket-hello/hello";

function getRootUri() {
return "ws://" + (document.location.hostname == "" ? "localhost" :document.location.hostname) + ":" +
(document.location.port == "" ? "8080" :document.location.port);
}

function init() {
output = document.getElementById("output");
}

function send_message() {

websocket = new WebSocket(wsUri);
websocket.onopen = function(evt) {
onOpen(evt)
};
websocket.onmessage = function(evt) {
onMessage(evt)
};
websocket.onerror = function(evt) {
onError(evt)
};

}

function onOpen(evt) {
writeToScreen("Connected to Endpoint!");
doSend(textID.value);

}

function onMessage(evt) {
writeToScreen("Message Received: " + evt.data);
}

function onError(evt) {
writeToScreen('<span style="color: red;">ERROR:</span> ' + evt.data);
}

function doSend(message) {
writeToScreen("Message Sent: " + message);
websocket.send(message);
}

function writeToScreen(message) {
var pre = document.createElement("p");
pre.style.wordWrap = "break-word";
pre.innerHTML = message;

output.appendChild(pre);
}

window.addEventListener("load", init, false);

</script>

<h1 style="text-align: center;">Hello World WebSocket Client</h2>

<br>

<div style="text-align: center;">
<form action="">
<input onclick="send_message()" value="Send"type="button">
<input id="textID" name="message"value="Hello WebSocket!" type="text"><br>
</form>
</div>
<div id="output"></div>
</body>
</html>

如你所見，要想使用WebSocket協議與伺服器通信, 需要一個WebSocket對象。它會自動連接伺服器.

1

websocket = new WebSocket(wsUri);

連接上會觸發open事件：

1
2
3

websocket.onopen = function(evt) {
onOpen(evt)
};

一旦連接成功，則向伺服器發送一個簡單的hello消息。

1

websocket.send(message);

伺服器端代碼
有兩種創建伺服器端代碼的方法：
註解方式Annotation-driven: 通過在POJO加上註解, 開發者就可以處理WebSocket 生命周期事件.
實現介面方式Interface-driven: 開發者可以實現Endpoint介面和聲明周期的各個方法.
建議開發時採用註解方式，這樣可以使用POJO就可以實現WebSocket Endpoint. 而且不限定處理事件的方法名。代碼也更簡單。
本例就採用註解的方式，接收WebSocket請求的類是一個POJO, 通過@ServerEndpoint標注. 這個註解告訴容器此類應該被當作一個WebSocket的Endpoint。value值就是WebSocket endpoint的path.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.sample.websocket;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/hello")
public class HelloWorldEndpoint {

@OnMessage
public String hello(String message) {
System.out.println("Received : "+ message);
return message;
}

@OnOpen
public void myOnOpen(Session session) {
System.out.println("WebSocket opened: " + session.getId());
}

@OnClose
public void myOnClose(CloseReason reason) {
System.out.println("Closing a WebSocket e to " + reason.getReasonPhrase());
}

}

注意：這個例子還包括了其它兩個回調函數： @OnOpen標注的方法在WebSocket連接開始時被調用， Web Session作為參數。另外一個@OnClose標注的方法在連接關閉時被調用。
就是這么簡單。但是為了編譯這個例子你還需要Websockets API的實現，它在WildFly 8發布中（或者你用JSR 356的參考實現，或其它的容器提供的jar，如tomcat）:

1

moles\system\layers\base\javax\websocket\api\main\jboss-websocket-api_1.0_spec-1.0.0.Final.jar

對於Maven用戶，你需要增加undertow-websockets-jsr依賴:

1
2
3
4
5

<dependency>
<groupId>org.jboss.spec.javax.websocket</groupId>
<artifactId>jboss-websocket-api_1.0_spec</artifactId>
<version>1.0.0.Final</version>
</dependency>

這個例子比較早，應該是2013年寫的,jsr 256還未發布。現在，你應該直接使用Java EE提供的API

1
2
3
4
5

<dependency>
<groupId>javax.websocket</groupId>
<artifactId>javax.websocket-api</artifactId>
<version>1.1</version>
</dependency>

編解碼器
前面的例子中WebSocket通信的消息類型默認為String。接下來的例子演示如何使用Encoder和Decoder傳輸更復雜的數據。
Websocket使用Decoder將文本消息轉換成Java對象，然後傳給@OnMessage方法處理; 而當對象寫入到session中時，Websocket將使用Encoder將Java對象轉換成文本，再發送給客戶端。
更常用的，我們使用XML 或者 JSON 來傳送數據，所以將會會將Java對象與XML/JSON數據相互轉換.
下圖描繪了客戶端和伺服器使用encoder/decoder標准通信過程。

聲明Encoder/Decoder也是相當的簡單: 你只需在@ServerEndpoint註解中增加encoder/decoder設置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package com.sample.websocket;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(value = "/hello",
decoders = {
MessageDecoder.class,},
encoders = {
MessageEncoder.class
})
public class HelloWorldEndpoint {

@OnMessage
public Person hello(Person person, Session session) {
if (person.getName().equals("john")) {
person.setName("Mr. John");
}
try {
session.getBasicRemote().sendObject(person);
System.out.println("sent ");
} catch (Exception ex) {
Logger.getLogger(HelloWorldEndpoint.class.getName()).log(Level.SEVERE, null, ex);
}
return person;

}

@OnOpen
public void myOnOpen(Session session) {
}

}

正像你看到的， OnMessage方法使用Java Object person作為參數，我們為名字增加個尊稱再返回給客戶端。通過session.getBasicRemote().sendObject(Object obj)返回數據.
容器負責使用你指定的Decoder將接收到的XML消息轉為Java對象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package com.sample.websocket;

import java.io.StringReader;

import javax.websocket.Decoder;
import javax.websocket.EndpointConfig;
import javax.xml.bind.*;

public class MessageDecoder implementsDecoder.Text<Person> {

@Override
public Person decode(String s) {
System.out.println("Incoming XML " + s);
Person person = null;
JAXBContext jaxbContext;
try {
jaxbContext = JAXBContext.newInstance(Person.class);

Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();

StringReader reader = new StringReader(s);
person = (Person) unmarshaller.unmarshal(reader);
} catch (Exception ex) {
ex.printStackTrace();
}
return person;
}

@Override
public boolean willDecode(String s) {

return (s != null);
}

@Override
public void init(EndpointConfig endpointConfig) {
// do nothing.
}

@Override
public void destroy() {
// do nothing.
}
}

這里我們使用JAXB做轉換。我們只要實現一個泛型介面Decoder.Text 或者 Decoder.Binary，根據你傳輸的數據是文本還是二進制選擇一個.
所以數據由Decoder解碼，傳給Endpoint (這里的 HelloWorldEndpoint)，在返回給client之前，它還會被下面的Encoder轉換成XML:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package com.sample.websocket;

import java.io.StringWriter;

import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;

public class MessageEncoder implementsEncoder.Text<Person> {

@Override
public String encode(Person object) throws EncodeException {

JAXBContext jaxbContext = null;
StringWriter st = null;
try {
jaxbContext = JAXBContext.newInstance(Person.class);

Marshaller marshaller = jaxbContext.createMarshaller();
st = new StringWriter();
marshaller.marshal(object, st);
System.out.println("OutGoing XML " + st.toString());

} catch (Exception ex) {
ex.printStackTrace();
}
return st.toString();
}

@Override
public void init(EndpointConfig endpointConfig) {
// do nothing.
}

@Override
public void destroy() {
// do nothing.
}
}

② Java後台傳時間對象到前台後台時間正確、前台時間相差8個小時是怎麼回事、、求大神解答

好像spring轉json的默認實現jackson中會根據時區去轉換時間，而jackson的默認時區跟國內是相差8小時的，回所以這里得重新答設置當前項目地所在時區。@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") 里加上 timezone = "GMT+8" 就行了

③ java怎樣在後台獲取前台jsp頁面文本框的value值

代碼示例：

java代碼片段：

String param1 = request.getParameter("xxid");//xxid為jsp表單元素中的name屬性。

jsp表單：

(3)java後台的值傳到前台擴展閱讀：

前後台傳參方式：

1、前台如果傳的是一個集合，後台可以使用參數 @RequestBody List<String> ids 來接收。

2、如果前台是這種傳值方式 data:{"name":name,"id":id}。

那後台可以通過創建一個欄位名稱對應的實體類來接收。

或者使用String name = request.getParameter("name")的方式來接收。

3、如果ajax選擇的GET方法，那後台方法的欄位名稱和url的入參名稱保持一致就能接收到數據了

4、window.location.href="<%=path%>/ui/psmpackage/toPsmPackageList";

④ java後端向前端傳遞數據(java前後端怎麼對接)

java中後台向前端傳值的幾種方式

當然在做web服務的時候，日誌非常重要，lombok提供了非常優良的日誌服務，這里引入lombok依賴的jar包。之前創建了一個springboot項目，這里需要在項目中增加程序的入口，也就是main方法Application。

一般使用兩種方式，一種是servlet的轉發或重定向跳轉頁面，並將信息攜帶過去，另一種方式是ajax請求後台介面，後台介面進行處理之後將信息返回給介面調用者。

前端和後端連接方式取決於應用程序的需求和技術棧，java常見的五種連接方式如下：RESTfulAPI使用RESTfulAPI是最常見的前後端連接方式，前端通過HTTP請求與後端進行通信，並獲取或提交數據。

後端Java怎麼和前端HTML交互?

java是屬於後台代碼，作用是獲取前端的請求並處理邏輯和資料庫處理。一般來說與前端網頁數據交互有兩用方式，一，ajax請求數據介面，然後前端根據返回值處理數據。二，使用request方式將返回值直接帶給跳轉頁面。建議使用第一種。

拿到設計稿後不要直接切割，然後到DW里直接敲代碼，首先要認真研究，把握大致的框架圖，做到心裡有一個整體的構思，其中還可以揣摩一些設計的風格，有興趣的朋友完全可以讓自己走上設計的道路。

後台用servlet處理數據，把需要傳到前台的數據存在作用域，在前台利用c：foreach標簽遍歷輸出到頁面。

這是一門課程了，javaweb或者叫jsp。jsp就是由html和java腳本，等語言構成的。java程序嵌套在html里，相當於php。以網頁的形式將java展現。這也就是所謂的動態。以為java程序獲取的時間會變動。

前端需要java後端傳多個對象數據怎麼傳?

1、很多時候前端需要傳遞多個不同類型對象到後台，這時可以將所有需上傳的對象保存在一個數組里，之後向後台上傳數組即可。

2、通過表單傳遞前端使用表單時，為name屬性賦值，後台controller層方法的參數只要與name的值相同，即可獲取到該屬性的值。ajaxjs中將值取出來，通過data這個key傳值，數據的值裡面也是以key、value的方式，即JSON格式。

3、一種，放到request、session、application域裡面。

4、使用form表單提交但是這里要記得添加enctype屬性，這個屬性是指定form表單在向伺服器提交之前，對表單數據如何進行編碼。文件域中的name=file屬性的值，需要和後台接收的對象名一致，不然接收不到。

作為java後端,在用protobuf的情況下我該給前端傳什麼形式的數據?

1、int32數據類型能表示負數，負數的最高位為1，如果負數也使用這種方式表示會出現一個問題，int32總是需要5個位元組，int64總是需要10個位元組。

2、Kryo是專門針對Java進行優化了的。所以在使用的便捷性上來說Kryo則更加方便。

3、Repeated：表示該欄位可以包含0~N個元素。其特性和optional一樣，但是每一次可以包含多個值。可以看作是在傳遞一個數組的值。②．數據類型Protobuf定義了一套基本數據類型。

4、而ProtobufHttpMessageConverter其實已經重寫了supports與canWrite方法：這里發現根源其實是Message.class.isAssignableFrom(clazz)返回的false。

5、Protocolbuf是Google開發的一種數據交換格式，它可以用於定義結構化數據，並且允許這些數據之間進行可移植的序列化。它可以更有效地表達數據，而且可以節省許多CPU和內存使用，因此Protocolbuf可以很好地支持大型伺服器後端應用程序。

⑤ java後台傳到前台的json數據怎麼解析

假設後台傳遞到前台數據的臨時對象為json（你上面那一長串）。varjson=「{……}」;json=eval('('+json+')');json就對前台對象了，json.endPlncre可以拿出指定屬性385

導航:首頁 > 編程語言 > java後台的值傳到前台

java後台的值傳到前台

與java後台的值傳到前台相關的資料

友情鏈接