在IE浏览器输入一个（？）Java代码可以攻入或侵占后台数据
那不是java代码，是html的get提交，比如后台接受参数username他前台不让输入注入漏洞
比如 ' or ''=' 这样的单引号之类 你用浏览器的get方式提交 绕过js验证。 其实就是注入
java编程：*黑*入*一个web服务器的思路是怎样的？高手进。
这个首先是你要确定想获得什么东西。。
需求不同，实现自然不同嘛。。
想要获取web服务器的管理密码？用户密码？主机密码？数据库密码？
还是要搞破坏？
方法都不一样的嘛。。
总的来说，
先抓包，看看对方用的是什么服务器。
然后试试这个服务器的默认密码、默认的路径之类的。
再有就是如楼上所说，去查看公开的漏洞，漏洞公开了，补丁出来了，但是不是所有的管理员都会打上补丁。你就可以对着漏洞的描述文档去专门的搞破坏了。
这个问题，你应该去一些黑客论坛找答案。。
用java写网站全部后台可以吗？请专业人士回答好吗，谢谢！
您好，首先答案是肯定的，Java在性能上，完全可以胜任后台开发。
网站后台，本质就是让服务器处理前端传来的数据，所以前端和服务器一般是配套的，比如你用JS+PHP模式或者JSP+SSH模式。
最初的时候，为了让Java写的前端程序跟服务器交互，SUN公司制定出servlet规范，根据这个规范，有人用Java编写出了Tomcat这样的servlet容器。那么我们只要编写符合语法的Java程序（也称servlet程序），就可以通过Tomcat与服务器交互了。
后来人们发现，Java与服务器交互完，向前台输出反馈时，使用servlet太麻烦了，于是，又制定出了JSP规范（JSP与HTML、JS可以混杂，因为它俩是在前端就被解释完的）。JSP底层还是servlet，但是它使用标签式的语法，极大减轻了开发人员的负担。
再后来，发现有些服务端的代码是经常被重用的，于是又制定了JavaBean标准，再扩大点就是EJB。
再然后，程序越写越大，复用也越来越频繁，然后人们将整个程序粗略地分为三部分：模型、视图、控制器，分别负责界面显示、业务逻辑和底层数据交互，这就是MVC模型，基于这个模型诞生了Struts+Hibernate+Spring这样辅助开发的SSH框架，使得Java在编写大型服务器程序时更便捷。
现在，大型的网站后台其实很多是用Java开发的，它更庞大，但也更安全、高效，当然开发成本也更高，所以我前面也只说Java在性能上完全可以胜任。如果你有计划做这方面的业务，那就根据业务需求，从性价比上制定规划吧，看PHP和Java哪个更合算。
-----您的采纳是我们的动力-----
怎样用Java写一个软件，可以通过这个软件登陆一个网站的后台，而不用通过浏览器进入网站后台？
登录有验证码吗？可以用htmlunit模仿浏览器登录来操作，可以参考这篇文章：
http://www.reader8.cn/jiaocheng/20121005/2079816.html
请问JAVA是怎么运用到网站后台开发的
一、程序运行界面：
1、总控制台
2、计划任务的设置界面。
3、控制台输出结果。
二、程序开发环境：
使用Java(JDK 1.4)开发，图形界面使用Eclipse （2.1.3版）的SWT方式开发。运行主机：P4 2.6+1G内存 windowsXP操作系统
三、预备。
开发此类程序，最好不要直接使用JAVA的线程来编程，这样会增加不必要的复杂度和难度，吃力不讨好。在JAVA中有一个包 java.util.Timer 这个包封装了对线程的操作，我们可以把它称做定时器类。我们先来看一个简单例子：
import java.util.Timer;
import java.util.TimerTask;
public class Reminder {
Timer timer;
public Reminder(int seconds) {
timer = new Timer();
timer.schedule(new RemindTask(),seconds*1000); //参数要求转化成毫秒
}
public static void main(String args[]) {
new Reminder(5); //5秒后运行
}
/**一个内部类，封装了所要运行的任务*/
class RemindTask extends TimerTask {
public void run() {
System.out.println("任务运行。。。。");
timer.cancel(); //结束timer中的所有任务
}
}
}
这里涉及于两个JAVA类Timer和TimerTask。我们继承TimerTask类后，将所要运行的任务封装其run方法中；Timer可以管理几千个任务（TimerTask），注意，同一个任务对象不能两次加入到Timer中执行。
对（虽然执行的任务都一样，但是两个任务对象）：
timer.schedule(new RemindTask(), seconds * 1000);
timer.schedule(new RemindTask(), seconds * 1000);
错
RemindTask task= new RemindTask();
timer.schedule(task, seconds * 1000);
timer.schedule(task, seconds * 2000);
四、设计方案。
主要的类图
说明：
任务类的设计。我们先创建一个抽象类AbstractTimerTask，这个类直接继承至TimerTask类，提供对TimerTask封装。然后所有具体的任务类（如：TimerTask_1）继承自AbstractTimerTask。
import java.util.TimerTask;
public abstract class AbstractTimerTask extends TimerTask {
TaskEntry taskEntry; //任务记录
public AbstractTimerTask(TaskEntry taskEntry) {
this.taskEntry = taskEntry;
}
/*
* 生成一个新的实例相当于克隆自身;原因在于：同一任务对象不能两次加入到Timer
* 在TaskEntry类将看到它的使用方法
*/
abstract AbstractTimerTask getCloneObject();
}
下面是它的一个实现类的源代码我们可以将要运行任务的代码写在这个类中。
import java.util.Calendar;
public class TimerTask_1 extends AbstractTimerTask {
public TimerTask_1(TaskEntry taskEntry) { //构造方法
super(taskEntry);
}
public AbstractTimerTask getCloneObject() {
return new TimerTask_1(taskEntry);
}
public void run() {
/*在这里写你要执行的程序。。。。。*/
System.out.println("??时："+taskEntry.getName()+"运行了一次");
this.taskEntry.taskStart(); //运行下一个时间点任务
}
}
在AbstractTimerTask类有一个TaskEntry字段，这是本设计的一个核心类,它代表一条封装完整的任务记录,每个任务类和它的运行计划都封装在这条类中,源代码如下。Timer和AbstractTimerTask前面都已说过,那么TimePlan是做什么用的呢？
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import mytimer.util.Util;
/**任务记录类*/
public class TaskEntry {
public static final int TASK_START = 0; //定义两个表示任务记录状态常量
public static final int TASK_STOP = 1;
private Long oid; //任务ID号，唯一
private String name; //任务名称
private int state = TASK_STOP; //任务状态（启动/停止）
private Timer timer; //JAVA计时器
private TimePlan timePlan; //时间计划的类型
private AbstractTimerTask timerTask; //任务类的种子对象,由这个对象来不断克隆
private AbstractTimerTask runTimerTask; //运行计划的当前任务
/**
* ITaskEntry.taskStart()--TimerTask.run()--ITaskEntry.taskStart()
* 形成一个循环回路。本方法负责起动本类代表的任务
*/
public void taskStart() {
if (timePlan.haveNext()) {
Date date = timePlan.nextDate();//得到任务计划时间
runTimerTask = timerTask.getCloneObject();//得到任务(复制)
timer.schedule(runTimerTask, date); //加入计划队列
//打印将要运行的计划任务的信息
Calendar c = Calendar.getInstance();
c.setTimeInMillis(runTimerTask.scheduledExecutionTime());
System.out.println(Util.dateToLongStr(c.getTime())+"将运行"+name);
} else {
state = TASK_STOP;
System.out.println(name + "结束");
}
}
/**停止任务*/
public void taskStop() {
if (runTimerTask != null) {
//打印信息
Calendar c = Calendar.getInstance();
c.setTimeInMillis(runTimerTask.scheduledExecutionTime());
System.out.println("计划于:"+Util.dateToLongStr(c.getTime())+"运行的" + name + "被终止");
//终止本任务, 调用Timer.cancel()是终止Timer的所有任务。
runTimerTask.cancel();
} else {
System.out.println(name + "未进入执行计划");
}
}
……… 一些属性的get/set方法（省略）
/** 监听类（内部类） */
public static class DateBeforeTodayException extends NullPointerException {
private Date date;
public DateBeforeTodayException(Date date) {this.date = date;}
public String toString() {
return "计划时间(" + Util.dateToLongStr(date) + ")早于当前时间";
}
}
}
1、TimePlan是一个接口(interface)，它是表示“运行计划的方案”，这个程序中提供了三种运行计划方案（见前图：计划任务的设置界面）：
一次性运行。
每隔一个时间段运行。
一周中选择那几天运行。
将它设计成一个接口是为了方便今后扩展，如果要新增新的时间方案只需要继承这个接口写一个新的实现即可。三种时间方案的类图如下：
说明：
a) TimePlan封装了五个方法，其它haveNext()和nextDate()最重要，这个两个方法模仿了Java中集合类（Collection）的迭代器(Iterator)的设计形式，代码如下：
import java.util.Date;
//时间计划方案的接口
public interface TimePlan {
boolean haveNext();//判断还有没有下一个计划时间
Date nextDate();//得到下一个计划时间
Date getCurrentDate();//得到开始时间
void setCurrentDate(Date date); //设计开始时间
String getTimePlanString();//显示运行计划方案的文字说明
}
b) AbstractTimePlan是这个抽象类，主要目的是将一些各子类的公共方法写在这里。代码如下：
import java.util.Date;
public abstract class AbstractTimePlan implements TimePlan {
//记录计划的第一时间点，除设置新的起始时间，否则不再改变
protected Date currentDate;
/*
当前计划的时间点，每次计划替换时被更新，
似乎这个才应叫cureentDate，sorry不想再改了
*/
protected Date planDate;
public boolean haveNext() {
return (planDate != null);
}
public Date getCurrentDate() {
return currentDate;
}
public void setCurrentDate(Date date) {
currentDate = date;
planDate = date; //在赋给currentDate值时，同时也赋给planDate
}
}
c) 然后我们看看三种计划方案的实现类的源代码：
//“一次性运行”的计划方案类
import java.util.Date;
public class TimePlanOnce extends AbstractTimePlan {
public Date nextDate() {
//把要当前的计划时间保存在中间变量中
Date returnDate = this.planDate;
//算出下一个计划时间。没有下一个就设为null
this.planDate = null;
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期");
return returnDate;
}
public String getTimePlanString() {
return "一次性运行,运行时间: （打印this.currentDate） ";
}
}
//“周期性间隔”的时间计划方案类
import java.util.Date;
public class TimePlanPeriod extends AbstractTimePlan {
public static final int HOUR = 0;
public static final int DAY = 1;
private int spaceTime; //间隔时间,单位毫秒
private int timeType;
public Date nextDate() {
//把要当前的计划时间保存在中间变量中
Date returnDate = this.planDate;
//算出下一个计划时间。没有下一个就设为null
int milliSecond = 0;
if (timeType ==HOUR) milliSecond = spaceTime * 1000; //小时*60*60*1000;
if (timeType ==DAY) milliSecond = spaceTime * 24 * 60 * 60 * 1000; //天
planDate = Util.DateAddSpaceMilliSecond(planDate, milliSecond);
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期");
return returnDate;
}
public String getTimePlanString() {
if (timeType == HOUR)
return "第一次运行于:currentDate.并每隔spaceTime小时运行一次";
if (timeType == DAY)
return "第一次运行于:currentDate.并每隔spaceTime天运行一次";
return "";
}
public int getSpaceTime() { return spaceTime; }
public int getTimeType() { return timeType; }
public void setSpaceTime(int i) { spaceTime = i; }
public void setTimeType(int i) { timeType = i; }
}
/**选择一周的某几天,让这几天在同一时间点运行任务, 一周内必须选择一天*/
import java.util.Calendar;
import java.util.Date;
public class TimePlanSelectWeek extends AbstractTimePlan {
private static Calendar c = Calendar.getInstance(); //取得一个日历实例
private static int spaceMilliSecond = 0; //间隔时间,单位毫秒
private boolean[] selectWeek = new boolean[7]; //0为星期日 ,1为星期一
public Date nextDate() {
Date returnDate = null;
if (!isSelectWeek(planDate)) //如果这一天不是所选周中的一天
planDate = getNextDate(planDate);
returnDate = planDate;
planDate = getNextDate(planDate);
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期");
return returnDate;
}
//算出下一个计划时间。没有下一个就设为null
private Date getNextDate(Date date) {
Date tempDate = date;
Date returnDate = null;
for (int i = 0; i 7; i++) {
tempDate = Util.DateAddSpaceMilliSecond(tempDate, spaceMilliSecond);
if (isSelectWeek(tempDate)) {
returnDate = tempDate;
break;
}
}
return returnDate;
}
/**设置某星期是否被选, 0为星期日 ,1为星期一....6为星期六*/
public void setSelectWeek(int i, boolean b) {selectWeek[i] = b;}
/** 判断某星期是否被选*/
public boolean isSelectWeek(int i) {return selectWeek[i];}
/**判断某天所属星期几是否被选*/
public boolean isSelectWeek(Date date) {
if (date == null) return false;
c.setTime(date);
//Calendar.DAY_OF_WEEK:星期日=1,星期六=7 c.get(Calendar.DAY_OF_WEEK)
return isSelectWeek(c.get(Calendar.DAY_OF_WEEK) - 1);
}
public String getTimePlanString() {
StringBuffer sb = new StringBuffer("");
if (selectWeek[1]) sb.append("周一,");
if (selectWeek[2]) sb.append("周二,");
if (selectWeek[3]) sb.append("周三,");
if (selectWeek[4]) sb.append("周四,");
if (selectWeek[5]) sb.append("周五,");
if (selectWeek[6]) sb.append("周六,");
if (selectWeek[0]) sb.append("周日,");
return "每周的"+sb.toString()+"运行";
}
}
TimerTask的工厂类。将生成TimerTask的代码另起一个类的好处是代码的层次比较清楚，也比较好管理。由于TimerTask包含有几个字段，因此产生一个TimerTask对象还是有一定的复杂度，建立一个专门生成TimerTask的工厂类，这样我们在生成一个TimerTask对象时就可以少掉很多麻烦的代码了。当然由于我的工作任务，只需要一个TimerTask对象就够了，所以最初之前我是将它直接写在图形界面的代码里的。
这里建立一个TimerTask对象池tasks，它是一个静态变量，这样在getInstance时不必总是要新生成一个TimerTask。还有Timer也是一个静态变量，它是一个全局单例（是最简单的单例模式了），因为前面说了Timer可以管理几千个任务，所以Timer对象一个就够了。
import java.util.HashMap;
import java.util.Timer;
public class TaskEntryFactory {
private static final HashMap tasks = new HashMap();
private static final Timer timer = new Timer();
public static TaskEntry getInstance(Long oid, String name) {
if (tasks.containsKey(oid)) {
return (TaskEntry) tasks.get(oid);
} else {
TaskEntry entry = new TaskEntry();
entry.setOid(oid);
entry.setName(name);
entry.setTimer(timer);
entry.setTimerTask(new TimerTask_1(entry));
tasks.put(oid, entry);
return entry;
}
}
}
起动和停止任务,当“任务设置界面（TaskListDialog.java）”点击OK后处理。界面的编写就不在本文讨论的范围内了。
//任务设置界面中点击”确认(OK)”按钮后的处理
if (dialog.open() == Window.OK) {
if (taskEntry.getState() == TaskEntry.TASK_START) {
taskEntry.taskStop();//将旧的停掉
taskEntry.taskStart();//开始新设置的
}
if (taskEntry.getState() == TaskEntry.TASK_STOP)
taskEntry.taskStop();
tv.refresh(taskEntry);
}