普通的Java程序能否直接在Tomcat等应用服务器WEB服务器上运行？

应该是不行的。Java有专门的服务器端程序，只要你的类继承Serlvet或者>

随着互联网的不断发展，无服务器应用编程开发成为了程序员学习的又一个发展方向，下面北大青鸟就一起来了解一下，实现无服务器编程开发的框架都有哪些呢。

Nimbus是一个旨在简化FaaS应用程序开发、测试和部署的Java框架。Nimbus提供了一组与云平台无关的公共接口，用于与云提供商的无服务器功能发生交互。

对于那些想要开发简单的应用程序的新手们来说，他们需要面临非常陡峭的学习曲线。他们可能只想要部署一些>

Nimbus的主要优势是不需要通过创建配置文件来声明云资源(如AWSSAM或者Serverless框架)，这样开发人员“就不会因为忘记了某些参数而犯错”。另外，Nimbus会对部署参数进行编译时检查，以便尽早检测出错误。

Nimbus还支持其他的 *** 作：

WebSocketFunction：用于处理websocket请求;

DocumentStoreFunction：用于执行因文档存储变更而触发的代码;

KeyValueStoreFunction：用于执行因键值存储变更而触发的代码;

NotificationFunction：用于执行由通知触发的代码;

QueueFunction：用于执行因队列变化而触发的代码;

BasicFunction：用于执行不需要触发器的代码;

FileStorageFunction：用于执行基于文件存储事件(文件创建和删除)的代码;

AfterDeploymentFunction：用于执行部署之后需要立即执行的 *** 作。

除了支持各种不同的 *** 作之外，Nimbus还支持几种数据存储类型。

其他支持的数据存储(和客户端)包括：用于存储关系型数据的关系型存储、用于存储键值数据的键值存储和用于存储对象的文件存储(支持静态网站托管和文件上传)。

测试也是构建无服务器应用程序的另一个常见难点。Nimbus提供了单元测试和集成测试支持。在进行单元测试时，可以为上述列表中的任何一个 *** 作创建本地部署，可以接受请求，并验证函数是否被正确调用，或者数据是否被正确保存。Nimbus对集成测试的支持相对有限，只支持基于>

import javaio;
import javanet;public class ftpServer extends Thread{ public static void main(String args[]){
String initDir;
initDir = "D:/Ftp";
ServerSocket server;
Socket socket;
String s;
String user;
String password;
user = "root";
password = "123456";
try{
Systemoutprintln("MYFTP服务器启动");
Systemoutprintln("正在等待连接");
//监听21号端口
server = new ServerSocket(21);
socket = serveraccept();
Systemoutprintln("连接成功");
Systemoutprintln("");
Systemoutprintln("");

InputStream in =socketgetInputStream();
OutputStream out = socketgetOutputStream();

DataInputStream din = new DataInputStream(in);
DataOutputStream dout=new DataOutputStream(out);
Systemoutprintln("请等待验证客户信息");

while(true){
s = dinreadUTF();
if(strim()equals("LOGIN "+user)){
s = "请输入密码:";
doutwriteUTF(s);
s = dinreadUTF();
if(strim()equals(password)){
s = "连接成功。";
doutwriteUTF(s);
break;
}
else{s ="密码错误，请重新输入用户名：";<br> doutwriteUTF(s);<br> <br> }
}
else{
s = "您输入的命令不正确或此用户不存在，请重新输入：";
doutwriteUTF(s);
}
}
Systemoutprintln("验证客户信息完毕"); while(true){
Systemoutprintln("");
Systemoutprintln("");
s = dinreadUTF();
if(strim()equals("DIR")){
String output = "";
File file = new File(initDir);
String[] dirStructure = new String[10];
dirStructure= filelist();
for(int i=0;i<dirStructurelength;i++){
output +=dirStructure[i]+"\n";
}
s=output;
doutwriteUTF(s);
}
else if(sstartsWith("GET")){
s = ssubstring(3);
s = strim();
File file = new File(initDir);
String[] dirStructure = new String[10];
dirStructure= filelist();
String e= s;
int i=0;
s ="不存在";
while(true){
if(eequals(dirStructure[i])){
s="存在";
doutwriteUTF(s);
RandomAccessFile outFile = new RandomAccessFile(initDir+"/"+e,"r");
byte byteBuffer[]= new byte[1024];
int amount;
while((amount = outFileread(byteBuffer)) != -1){
doutwrite(byteBuffer, 0, amount);break;
}break;

}
else if(i<dirStructurelength-1){
i++;
}
else{
doutwriteUTF(s);
break;
}
}
}
else if(sstartsWith("PUT")){
s = ssubstring(3);
s = strim();
RandomAccessFile inFile = new RandomAccessFile(initDir+"/"+s,"rw");
byte byteBuffer[] = new byte[1024];
int amount;
while((amount =dinread(byteBuffer) )!= -1){
inFilewrite(byteBuffer, 0, amount);break;
}
}
else if(strim()equals("BYE"))break;
else{
s = "您输入的命令不正确或此用户不存在，请重新输入：";
doutwriteUTF(s);
}
}

dinclose();
doutclose();
inclose();
outclose();
socketclose();
}
catch(Exception e){
Systemoutprintln("MYFTP关闭!"+e);

}
}}

153 服务多个客户
JabberServer可以正常工作，但每次只能为一个客户程序提供服务。在典型的服务器中，我们希望同时能处理多个客户的请求。解决这个问题的关键就是多线程处理机制。而对于那些本身不支持多线程的语言，达到这个要求无疑是异常困难的。通过第14章的学习，大家已经知道Java已对多线程的处理进行了尽可能的简化。由于Java的线程处理方式非常直接，所以让服务器控制多名客户并不是件难事。
最基本的方法是在服务器（程序）里创建单个ServerSocket，并调用accept()来等候一个新连接。一旦accept()返回，我们就取得结果获得的Socket，并用它新建一个线程，令其只为那个特定的客户服务。然后再调用accept()，等候下一次新的连接请求。
对于下面这段服务器代码，大家可发现它与JabberServerjava例子非常相似，只是为一个特定的客户提供服务的所有 *** 作都已移入一个独立的线程类中：
//: MultiJabberServerjava
// A server that uses multithreading to handle
// any number of clients
import javaio;
import javanet;
class ServeOneJabber extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ServeOneJabber(Socket s)
throws IOException {
socket = s;
in =
new BufferedReader(
new InputStreamReader(
socketgetInputStream()));
// Enable auto-flush:
out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socketgetOutputStream())), true);
// If any of the above calls throw an
// exception, the caller is responsible for
// closing the socket Otherwise the thread
// will close it
start(); // Calls run()
}
public void run() {
try {
while (true) {
String str = inreadLine();
if (strequals("END")) break;
Systemoutprintln("Echoing: " + str);
outprintln(str);
}
Systemoutprintln("closing");
} catch (IOException e) {
} finally {
try {
socketclose();
} catch(IOException e) {}
}
}
}
public class MultiJabberServer {
static final int PORT = 8080;
public static void main(String[] args)
throws IOException {
ServerSocket s = new ServerSocket(PORT);
Systemoutprintln("Server Started");
try {
while(true) {
// Blocks until a connection occurs:
Socket socket = saccept();
try {
new ServeOneJabber(socket);
} catch(IOException e) {
// If it fails, close the socket,
// otherwise the thread will close it:
socketclose();
}
}
} finally {
sclose();
}
}
} ///:~
每次有新客户请求建立一个连接时，ServeOneJabber线程都会取得由accept()在main()中生成的Socket对象。然后和往常一样，它创建一个BufferedReader，并用Socket自动刷新PrintWriter对象。最后，它调用Thread的特殊方法start()，令其进行线程的初始化，然后调用run()。这里采取的 *** 作与前例是一样的：从套扫字读入某些东西，然后把它原样反馈回去，直到遇到一个特殊的"END"结束标志为止。
同样地，套接字的清除必须进行谨慎的设计。就目前这种情况来说，套接字是在ServeOneJabber外部创建的，所以清除工作可以“共享”。若ServeOneJabber构建器失败，那么只需向调用者“掷”出一个违例即可，然后由调用者负责线程的清除。但假如构建器成功，那么必须由ServeOneJabber对象负责线程的清除，这是在它的run()里进行的。
请注意MultiJabberServer有多么简单。和以前一样，我们创建一个ServerSocket，并调用accept()允许一个新连接的建立。但这一次，accept()的返回值（一个套接字）将传递给用于ServeOneJabber的构建器，由它创建一个新线程，并对那个连接进行控制。连接中断后，线程便可简单地消失。
如果ServerSocket创建失败，则再一次通过main()掷出违例。如果成功，则位于外层的try-finally代码块可以担保正确的清除。位于内层的try-catch块只负责防范ServeOneJabber构建器的失败；若构建器成功，则ServeOneJabber线程会将对应的套接字关掉。
为了证实服务器代码确实能为多名客户提供服务，下面这个程序将创建许多客户（使用线程），并同相同的服务器建立连接。每个线程的“存在时间”都是有限的。一旦到期，就留出空间以便创建一个新线程。允许创建的线程的最大数量是由final int maxthreads决定的。大家会注意到这个值非常关键，因为假如把它设得很大，线程便有可能耗尽资源，并产生不可预知的程序错误。
//: MultiJabberClientjava
// Client that tests the MultiJabberServer
// by starting up multiple clients
import javanet;
import javaio;
class JabberClientThread extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
private static int counter = 0;
private int id = counter++;
private static int threadcount = 0;
public static int threadCount() {
return threadcount;
}
public JabberClientThread(InetAddress addr) {
Systemoutprintln("Making client " + id);
threadcount++;
try {
socket =
new Socket(addr, MultiJabberServerPORT);
} catch(IOException e) {
// If the creation of the socket fails,
// nothing needs to be cleaned up
}
try {
in =
new BufferedReader(
new InputStreamReader(
socketgetInputStream()));
// Enable auto-flush:
out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socketgetOutputStream())), true);
start();
} catch(IOException e) {
// The socket should be closed on any
// failures other than the socket
// constructor:
try {
socketclose();
} catch(IOException e2) {}
}
// Otherwise the socket will be closed by
// the run() method of the thread
}
public void run() {
try {
for(int i = 0; i < 25; i++) {
outprintln("Client " + id + ": " + i);
String str = inreadLine();
Systemoutprintln(str);
}
outprintln("END");
} catch(IOException e) {
} finally {
// Always close it:
try {
socketclose();
} catch(IOException e) {}
threadcount--; // Ending this thread
}
}
}
public class MultiJabberClient {
static final int MAX_THREADS = 40;
public static void main(String[] args)
throws IOException, InterruptedException {
InetAddress addr =
InetAddressgetByName(null);
while(true) {
if(JabberClientThreadthreadCount()
< MAX_THREADS)
new JabberClientThread(addr);
ThreadcurrentThread()sleep(100);
}
}
} ///:~
JabberClientThread构建器获取一个InetAddress，并用它打开一个套接字。大家可能已看出了这样的一个套路：Socket肯定用于创建某种Reader以及／或者Writer（或者InputStream和／或OutputStream）对象，这是运用Socket的唯一方式（当然，我们可考虑编写一、两个类，令其自动完成这些 *** 作，避免大量重复的代码编写工作）。同样地，start()执行线程的初始化，并调用run()。在这里，消息发送给服务器，而来自服务器的信息则在屏幕上回显出来。然而，线程的“存在时间”是有限的，最终都会结束。注意在套接字创建好以后，但在构建器完成之前，假若构建器失败，套接字会被清除。否则，为套接字调用close()的责任便落到了run()方法的头上。
threadcount跟踪计算目前存在的JabberClientThread对象的数量。它将作为构建器的一部分增值，并在run()退出时减值（run()退出意味着线程中止）。在MultiJabberClientmain()中，大家可以看到线程的数量会得到检查。若数量太多，则多余的暂时不创建。方法随后进入“休眠”状态。这样一来，一旦部分线程最后被中止，多作的那些线程就可以创建了。大家可试验一下逐渐增大MAX_THREADS，看看对于你使用的系统来说，建立多少线程（连接）才会使您的系统资源降低到危险程度。

如果只有自己电脑连,局域网不能连,那有可能是端口没有开放,请关闭防火墙试试,
如果你想让外网的电脑访问,那你得有固定IP,(公网IP 或者用花生壳,域名转发,并且路由器需要做映射)

//ServerSocket
import javaio;
import javanet;
public class TcpServer {
    public static void main(String[] args) throws Exception{
        ServerSocket server = new ServerSocket(10003);
        Socket client = serveraccept();
        InputStream is = clientgetInputStream();
        OutputStream os = clientgetOutputStream();
        byte[] by = new byte[1024];
        int len = 0;
        String msg = null;
        while((len=isread(by))!=-1){
            msg = new String(by,0,len);
            Systemoutprintln("来自"+clientgetInetAddress()getHostAddress()+"客户端的消息："+msg);
            if("886"equals(msg))
                break;
            oswrite(getPrint(msg));
        }
        clientclose();
    }
    private static byte[] getPrint(String msg){
        return msggetBytes();
    }
}//Socket
import javaio;
import javanet;
public class TcpClient {
    public static void main(String[] args) throws Exception{
        Socket sk = new Socket("localhost",10003);
        OutputStream os = skgetOutputStream();
        InputStream is = skgetInputStream();
        oswrite(getPrint());
        byte[] by = new byte[1024];
        int len = 0;
        while((len=isread(by))!=-1){
            Systemoutprintln("来自"+skgetInetAddress()getHostAddress()+"服务器的消息："+new String(by,0,len));
            oswrite(getPrint());
        }
        skclose();
    }
    private static byte[] getPrint()throws Exception{
        BufferedReader in = new BufferedReader(new InputStreamReader(Systemin));
        String msg = inreadLine();
        return msggetBytes();
    }
}

//一下是输出结果：

来自127001客户端的消息：Hello
来自127001客户端的消息：eee
来自127001客户端的消息：886
//客户端：

Hello
来自127001服务器的消息：Hello
eee
来自127001服务器的消息：eee
886

提示：如果提问者想使用DataInputStream可以自行替换掉即可。

如何用Java实现Web服务器 一、>

在进行软件开发了解之后，很多人发现现在最流行的开发语言主要为Java，学习之后可以考虑很多不同的工作，那么在学习Java软件开发之后能够做什么呢？想要进入互联网行业，经验是非常重要的，如果没有工作经验想要找到一份软件开发的工作是比较困难的。下面IT培训为大家介绍学习软件开发之后能够做的工作。

在学习软件开发的过程中，很多人会选择考虑Java开发，并且现在Java开发是非常紧缺的，那么学习Java开发之后可以从事什么呢？

一、Android应用

很多人对Java软件开发不了解，最担心的就是就业问题一个学Java开发的，应该找什么样的工作呢？Java可以应用在哪些方法。其实Java的应用是非常广泛的，Java能够很好的应用在身边，最接近生活的就是Android手机的应用，在进手机APP开发的过程中，Java软件知识也是必不可少的，在进行APP开发的过程中，需要Java语言进行使用，这样能够让Java开发技术很好的融入生活中。

二、服务器程序

Java在金融行业中的应用是非常广泛的，在很多银行中开始使用软件开发。在金融行业中，Java被广泛的应用在服务器端的开发中，一般情况下，主要用于编写前台和后台的电子交易系统及其他数据处理项目中。但是java课程培训机构发现在进行服务器开发的过程中，几乎是没有任何前端的，主要用于服务器上面接收数据。

三、网站领域

Java在电子商务和网站开发领域占很大的席位，在进行网站建设的过程中，可以使用很多不同的框架进行网站搭建。在政府项目中，JSP的使用是最基础的，这些网站的开发主要是基于Java基础进行的。

Java的应用是非常广泛的，大家在学习Java开发之前可以进行提前了解，在选择学习的过程中一定不要盲目跟从，否则只会浪费自己的时间和金钱。电脑培训建议在没有任何基础的情况下，可以选择培训机构进行学习，这样能够帮助你快速掌握Java基础。

---