java 怎样通过客户端让服务器端连接数据库

嗯，你需要给与相应的权限。经服务器验证成功后，就可以连接到数据库。
通常客户端使用的都是默认的游客权限，所以你要修改游客的权限。
当然你也可以新建一个用户。
建议你给予客户端的权限，不要给管理员权限。要尽可能的限制它的权限

服务器端可以采用多线程处理客户请求，例如：
package threadPool;
import javaioBufferedReader;
import javaioIOException;
import javaioInputStream;
import javaioInputStreamReader;
import javaioOutputStream;
import javaioPrintWriter;
import javanetServerSocket;
import javanetSocket;
import javautilconcurrentExecutorService;
import javautilconcurrentExecutors;
public class ThreadPoolServer {

private int port = 8000;
private ServerSocket serverSocket;
private ExecutorService executorService; //线程池
private final int POOL_SIZE = 4; //单个CPU时线程池中的工作线程数目

public ThreadPoolServer() throws IOException{
serverSocket = new ServerSocket(port);

//创建线程池
//Runtime 的availableProcessors()方法返回当前系统CPU的数目
//系统CPU越多，线程池中的工作线程数目越多
executorService = ExecutorsnewFixedThreadPool(RuntimegetRuntime()availableProcessors()POOL_SIZE);

Systemoutprintln("服务器已启动！！");
}

public void service(){
while(true){
Socket socket = null;
try{
socket = serverSocketaccept();
executorServiceexecute(new Handler(socket));
}catch(IOException e){
eprintStackTrace();
}
}
}
public static void main(String[] args) {
try {
new ThreadPoolServer()service();
} catch (IOException e) {
eprintStackTrace();
}
}
}
class Handler implements Runnable {
private Socket socket;
public Handler(Socket socket) {
thissocket = socket;
}
private PrintWriter getWriter(Socket socket) throws IOException {
OutputStream socketOut = socketgetOutputStream();
return new PrintWriter(socketOut, true);
}
private BufferedReader getReader(Socket socket) throws IOException {
InputStream socketIn = socketgetInputStream();
return new BufferedReader(new InputStreamReader(socketIn));
}
public String echo(String msg) {
return "echo:" + msg;
}
@Override
public void run() {
try {
Systemoutprintln("New connection accepted:" + socketgetInetAddress() + ":" + socketgetPort());
BufferedReader br = getReader(socket);
PrintWriter pw = getWriter(socket);
String msg = null;
while ((msg = brreadLine()) != null) {
Systemoutprintln(msg);
pwprintln(echo(msg));
if (msgequals("bye")) {
break;
}
}
} catch (IOException e) {
eprintStackTrace();
} finally {
try {
if (socket != null)
socketclose();
} catch (IOException e) {
eprintStackTrace();
}
}
}
}

服务器端代码：
import javaioBufferedReader;
import javaioIOException;
import javaioInputStreamReader;
import javaioPrintStream;
import javanetServerSocket;
import javanetSocket;
/
Socket通讯服务器端
@author 米强

/
public class ServerMain {
public ServerMain() {
try {
// 构造服务器ServerSocket对象，参数为服务器端开放的端口号
ServerSocket ss = new ServerSocket(30102);
Systemoutprintln("服务器准备就绪！");
// 死循环可以使服务器持续处于接收客户端状态
while(true){
// 该方法使程序阻塞，等待客户端的链接，当监听到客户端的链接，创建一个Socket对象与客户端单独会话
Socket s = ssaccept();
// 为了不影响服务器监听其它客户端，这里开启了一个线程，由线程处理与这个客户端的会话
new ServerThread(s)start();
}
} catch (IOException e) {
eprintStackTrace();
}
}
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) {
thiss = s;
try {
// 从Socket中获取输入流和输出流，由于我们只做一个简单的字符串通讯，所以采用BufferedRead和PrintStream来封装输入、输出流
read = new BufferedReader(new InputStreamReader(sgetInputStream()));
print = new PrintStream(sgetOutputStream());
} catch (IOException e) {
eprintStackTrace();
}
}
/
线程的运行run方法
/
public void run() {
try {
String message = null;
// 这里循环可以使服务器持续的接收客户端信息。readreadLine()通过输入流读取一段字符串，赋值给message变量，如果message字符串不为“exit”则循环，否则结束循环
while (!(message = readreadLine())equals("exit")){
// 将字符串前面添加“返回：”，再发回客户端
printprintln("返回：" + message);
}
} catch (IOException e) {
} finally {
// 在 finally 代码块中无论如何都会执行下面代码：
try {
// 如果没有关闭Socket
if(!sisClosed()){
// 关闭Socket链接
sclose();
}
} catch (IOException e1) {
e1printStackTrace();
}
}
}
}
客户端代码：
import javaioBufferedReader;
import javaioIOException;
import javaioInputStreamReader;
import javaioPrintStream;
import javanetSocket;
import javanetUnknownHostException;
import javautilScanner;
/
Socket通讯客户端
@author 米强

/
public class ClientMain {
public ClientMain() {
try {
// 构造与服务器通讯的Socket对象，参数为服务器IP地址（String）和端口号（int），端口号需要和服务器端开放的端口号对应
Socket s = new Socket("1921681100", 30102);
// 启动一个线程与服务器通讯，并把链接服务器的Socket对象传递过去
new LinkThread(s)start();
} catch (UnknownHostException e) {
eprintStackTrace();
} catch (IOException e) {
eprintStackTrace();
}
}
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方法中我们还要用它断开链接
thiss = s;
try {
// 从Socket中获取输入流和输出流，由于我们只做一个简单的字符串通讯，所以采用BufferedRead和PrintStream来封装输入、输出流
out = new PrintStream(sgetOutputStream());
in = new BufferedReader(new InputStreamReader(sgetInputStream()));
} catch (UnknownHostException e) {
eprintStackTrace();
} catch (IOException e) {
eprintStackTrace();
}
}

/
线程的运行run方法
/
public void run() {
// 构造Scanner对象
scanner = new Scanner(Systemin);
Systemoutprintln("提示：如果要结束本次会话，请输入“exit”指令！");
try {
// 死循环可以使客户端不断的向服务器发送信息，不用担心循环无法结束，后面的return语句可以结束整个线程。
while(true){
// 提示用户输入文字
Systemoutprint("请输入：");
// 将用户输入的字符串保存在message变量中
String message = scannernextLine();
// 通过输出流发送字符串
outprintln(message);
// 清空缓冲，强制输出
outflush();
// 获取服务器返回的字符串
String str = inreadLine();
// 如果返回的字符串存在
if(str != null){
// 显示在控制台
Systemoutprintln(str);
}else{
// 提示会话结束，并结束线程
Systemoutprintln("本次会话结束！");
return;
}
}
} catch (IOException e) {
eprintStackTrace();
} finally {
// 在 finally 代码块中无论如何都会执行下面代码：
try {
// 如果没有关闭Socket
if(!sisClosed()){
// 关闭Socket链接
sclose();
}
} catch (IOException e1) {
e1printStackTrace();
}
}
}

}

---