1、java服务器开发是做什么？和web端的区别是什么？
web开发，是开发服务端的，开发好的web程序，打包成war，然后放到web容器中运行，而web容器，是部署在服务器中的。
web的客户端就是浏览器，教你设计页面，学CSS/HTML之类的。
标准的web服务器只具有与客户端浏览器通讯的功能，不能处理业务逻辑请求。
需要编写程序来复制处理客户端的请求。通过组件来处理客户端的请求，这个组件就是实现特定规范的可以单独部署的软件模块。组件必须通过容器来实现。容器是实现特定规范的程序，负责组件的运行环境和管理组件的生命周期。tomcat，weblogic都提供了容器。
web端可以理解为tomcat，并且tomcat中运行着你编写的程序，这个程序称为web应用。
java服务器开发就是通过java语言来编写程序，组合成web应用，将来部署到tomcat中，
编写的这些程序就是组件，用来处理客户端请求的。为了高效还会使用一些框架和技术来配合java程序，比如SpringMVC，struts2，Servlet。
2、Java用来编写客户端还是服务器端？
两者都可以...不过java的垃圾回收机制因为是自动的所以执行客户端程序的时候效率特别慢...一般用于服务器端或WEB开发...学java的重点就是以j2ee技术为核心的。想写客户端之类的用C语言是最佳的..不过内存处理机制全部自己编写..难度不是一般的高。
3、java中如何实现从客户端发送文件到服务器端
服务器端源码：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
*
* 文件名：ServerReceive.java
* 实现功能：作为服务器接收客户端发送的文件
*
* 具体实现过程：
* 1、建立SocketServer，等待客户端的连接
* 2、当有客户端连接的时候，按照双方的约定，这时要读取一行数据
* 其中保存客户端要发送的文件名和文件大小信息
* 3、根据文件名在本地创建文件，并建立好流通信
* 4、循环接收数据包，将数据包写入文件
* 5、当接收数据的长度等于提前文件发过来的文件长度，即表示文件接收完毕，关闭文件
* 6、文件接收工作结束
public class ServerReceive {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
ServerSocket ss = null;
Socket s = null;
/**定义用于在接收后在本地创建的文件对象和文件输出流对象*/
File file = null;
FileOutputStream fos = null;
/**定义输入流，使用socket的inputStream对数据包进行输入*/
InputStream is = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[4096 * 5];
/**用来接收文件发送请求的字符串*/
String comm = null;
/**建立socekt通信，等待服务器进行连接*/
try {
ss = new ServerSocket(4004);
s = ss.accept();
} catch (IOException e) {
e.printStackTrace();
}
/**读取一行客户端发送过来的约定信息*/
try {
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
comm = br.readLine();
} catch (IOException e) {
System.out.println("服务器与客户端断开连接");
}
/**开始解析客户端发送过来的请求命令*/
int index = comm.indexOf("/#");
/**判断协议是否为发送文件的协议*/
String xieyi = comm.substring(0, index);
if(!xieyi.equals("111")){
System.out.println("服务器收到的协议码不正确");
return;
}
/**解析出文件的名字和大小*/
comm = comm.substring(index + 2);
index = comm.indexOf("/#");
String filename = comm.substring(0, index).trim();
String filesize = comm.substring(index + 2).trim();
/**创建空文件，用来进行接收文件*/
file = new File(filename);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("服务器端创建文件失败");
}
}else{
/**在此也可以询问是否覆盖*/
System.out.println("本路径已存在相同文件，进行覆盖");
}
/**【以上就是客户端代码中写到的服务器的准备部分】*/
/**
* 服务器接收文件的关键代码*/
try {
/**将文件包装到文件输出流对象中*/
fos = new FileOutputStream(file);
long file_size = Long.parseLong(filesize);
is = s.getInputStream();
/**size为每次接收数据包的长度*/
int size = 0;
/**count用来记录已接收到文件的长度*/
long count = 0;
/**使用while循环接收数据包*/
while(count < file_size){
/**从输入流中读取一个数据包*/
size = is.read(buffer);
/**将刚刚读取的数据包写到本地文件中去*/
fos.write(buffer, 0, size);
fos.flush();
/**将已接收到文件的长度+size*/
count += size;
System.out.println("服务器端接收到数据包，大小为" + size);
}
} catch (FileNotFoundException e) {
System.out.println("服务器写文件失败");
} catch (IOException e) {
System.out.println("服务器：客户端断开连接");
}finally{
/**
* 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ServerReceive
客户端源码：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/**
*
* 文件名：ClientSend.java
* 实现功能：作为客户端向服务器发送一个文件
*
* 具体实现过程：
* 1、建立与服务器端的连接，IP：127.0.0.1， port：4004
* 2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器
* 3、循环读取本地文件，将文件打包发送到数据输出流中
* 4、关闭文件，结束传输
*
* */
public class ClientSend {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
Socket s = null;
/**定义文件对象，即为要发送的文件
* 如果使用绝对路径，不要忘记使用'/'和'\'的区别
* 具体区别，请读者自行查询
* */
File sendfile = new File("API.CHM");
/**定义文件输入流，用来打开、读取即将要发送的文件*/
FileInputStream fis = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[4096 * 5];
/**定义输出流，使用socket的outputStream对数据包进行输出*/
OutputStream os = null;
/**检查要发送的文件是否存在*/
if(!sendfile.exists()){
System.out.println("客户端：要发送的文件不存在");
return;
}
/**与服务器建立连接*/
try {
s = new Socket("127.0.0.1", 4004);
}catch (IOException e) {
System.out.println("未连接到服务器");
}
/**用文件对象初始化fis对象
* 以便于可以提取出文件的大小
* */
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
/**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作
* 具体的准备工作，请查看服务器代码。
*
* 发送的内容包括：发送文件协议码（此处为111）/#文件名（带后缀名）/#文件大小
* */
try {
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("111/#" + sendfile.getName() + "/#" + fis.available());
ps.flush();
} catch (IOException e) {
System.out.println("服务器连接中断");
}
/**
* 此处睡眠2s，等待服务器把相关的工作准备好
* 也是为了保证网络的延迟
* 读者可自行选择添加此代码
* */
try {
Thread.sleep(2000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
/**之前的准备工作结束之后
* 下面就是文件传输的关键代码
* */
try {
/**获取socket的OutputStream，以便向其中写入数据包*/
os = s.getOutputStream();
/** size 用来记录每次读取文件的大小*/
int size = 0;
/**使用while循环读取文件，直到文件读取结束*/
while((size = fis.read(buffer)) != -1){
System.out.println("客户端发送数据包，大小为" + size);
/**向输出流中写入刚刚读到的数据包*/
os.write(buffer, 0, size);
/**刷新一下*/
os.flush();
}
} catch (FileNotFoundException e) {
System.out.println("客户端读取文件出错");
} catch (IOException e) {
System.out.println("客户端输出文件出错");
}finally{
/**
* 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fis != null)
fis.close();
} catch (IOException e) {
System.out.println("客户端文件关闭出错");
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ClientSend
4、java服务器接收客户端请求怎样实现的
服务器端代码：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* Socket通讯服务器端
* @author 米强
*
*/
public class ServerMain {
public ServerMain() {
try {
// 构造服务器ServerSocket对象，参数为服务器端开放的端口号
ServerSocket ss = new ServerSocket(30102);
System.out.println("服务器准备就绪！");
// 死循环可以使服务器持续处于接收客户端状态
while(true){
// 该方法使程序阻塞，等待客户端的链接，当监听到客户端的链接，创建一个Socket对象与客户端单独会话
Socket s = ss.accept();
// 为了不影响服务器监听其它客户端，这里开启了一个线程，由线程处理与这个客户端的会话
new ServerThread(s).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ServerMain();
}
}
/**
* 服务器端与客户端会话的线程
*/
class ServerThread extends Thread {
private Socket s = null;
private BufferedReader read = null;
private PrintStream print = null;
public ServerThread(Socket s) {
this.s = s;
try {
// 从Socket中获取输入流和输出流，由于我们只做一个简单的字符串通讯，所以采用BufferedRead和PrintStream来封装输入、输出流
read = new BufferedReader(new InputStreamReader(s.getInputStream()));
print = new PrintStream(s.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 线程的运行run方法
*/
public void run() {
try {
String message = null;
// 这里循环可以使服务器持续的接收客户端信息。read.readLine()通过输入流读取一段字符串，赋值给message变量，如果message字符串不为“exit”则循环，否则结束循环
while (!(message = read.readLine()).equals("exit")){
// 将字符串前面添加“返回：”，再发回客户端
print.println("返回：" + message);
}
} catch (IOException e) {
} finally {
// 在 finally 代码块中无论如何都会执行下面代码：
try {
// 如果没有关闭Socket
if(!s.isClosed()){
// 关闭Socket链接
s.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
客户端代码：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
/**
* Socket通讯客户端
* @author 米强
*
*/
public class ClientMain {
public ClientMain() {
try {
// 构造与服务器通讯的Socket对象，参数为服务器IP地址（String）和端口号（int），端口号需要和服务器端开放的端口号对应
Socket s = new Socket("192.168.1.100", 30102);
// 启动一个线程与服务器通讯，并把链接服务器的Socket对象传递过去
new LinkThread(s).start();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ClientMain();
}
}
/**
* 与服务器通讯的线程
*/
class LinkThread extends Thread {
private Socket s = null;
// 输出流
private PrintStream out = null;
// 缓冲输入流
private BufferedReader in = null;
// 录入文字的Scanner对象
private Scanner scanner = null;
public LinkThread(Socket s) {
// 将Socket对象实例保存在全局变量中，因为run方法中我们还要用它断开链接
this.s = s;
try {
// 从Socket中获取输入流和输出流，由于我们只做一个简单的字符串通讯，所以采用BufferedRead和PrintStream来封装输入、输出流
out = new PrintStream(s.getOutputStream());
in = new BufferedReader(new InputStreamReader(s.getInputStream()));
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 线程的运行run方法
*/
public void run() {
// 构造Scanner对象
scanner = new Scanner(System.in);
System.out.println("提示：如果要结束本次会话，请输入“exit”指令！");
try {
// 死循环可以使客户端不断的向服务器发送信息，不用担心循环无法结束，后面的return语句可以结束整个线程。
while(true){
// 提示用户输入文字
System.out.print("请输入：");
// 将用户输入的字符串保存在message变量中
String message = scanner.nextLine();
// 通过输出流发送字符串
out.println(message);
// 清空缓冲，强制输出
out.flush();
// 获取服务器返回的字符串
String str = in.readLine();
// 如果返回的字符串存在
if(str != null){
// 显示在控制台
System.out.println(str);
}else{
// 提示会话结束，并结束线程
System.out.println("本次会话结束！");
return;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 在 finally 代码块中无论如何都会执行下面代码：
try {
// 如果没有关闭Socket
if(!s.isClosed()){
// 关闭Socket链接
s.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
5、java 如何在使用java类 从客户端下载服务器上的文件
js 做不到 copy 到客户端指定位置
如果说的是java的话, 可以做到
import java.io.FileNotFoundException;6、java服务器端“/“文件路径如何书写？
在java中路径都这么写：\\ , 这个就是路径分隔符，以后就不用“/”了吧
不管是实在windows还是在linux中，你都用“\\”作为路径分隔符就对了
File.separator()这个方法是没什么问题，但是，你如果传入字符串后，
使用File.separator来split，可能会出错的哦，你在所有的地方，都用“\\”，
肯定是不会错的啦。
至于你说的json中也是，在java中就是用\\，这与json无关，而是转义导致的
7、用java编写app的服务器端，需要用到什么技术和框架
我也做服务端开发的，服务器和客户端传输数据使用到了servlet，为了提高效率使用了httpclient， 传输数据类型采用json，如果要跨语言开发那还要使用About thrift ，因为我们是做社交这块的，所以还要用到java socket技术，推送消息用的是极光推送，框架的话使用轻量级spring ICO DI ，然后数据库的话使用了三种 mongodb（主要使用） 、mysql（辅助）和redisdb（缓存）。大概就这么多了。还有app里面不全是原生开发，还可以使用html5进行辅助开发。