本文目录一览：
- 1、下面这段代码总是检测到XSS跨站脚本攻击漏洞找高手求解
- 2、您不信任我 阅读答案
- 3、java while loop 编程
- 4、sss框架和hibernate有什么联系
- 5、关于lingo，高手请入
- 6、sssccc java解析xml字符串
下面这段代码总是检测到XSS跨站脚本攻击漏洞找高手求解
是否有漏洞，取决于你输出的内容是否可信
比如echo $rows["Author"];
如$rows["Author"]里面是由用户输入且入库未过滤，那么直接输出时存在xss漏洞的。
如$rows["Author"]输入的值为〈script〉 alert( 1 )〈/script 〉
那么直接输出存在漏洞，
简单点修改 echo htmlentities($rows["Author"]),其他echo的类似
如果输出内容可信（过滤过，或来源可信安全）那么直接输出也不存在问题，程序检测的未必准确。
入库过滤了或者本身内容来源可靠不存在此漏洞。
您不信任我 阅读答案
1我想让等我去办点事，但是司机怕我溜掉，不信任我。
2。两人都不信任对方，却希望对方信任自己，因而在不服输又不愿意别人不信任自己是矛盾激化。
3矛盾激化，双方怎么看对方都不顺眼，一点点小瑕疵都无限放大，但双方冷静下来就觉得对方也并非那么不能看，而“可爱”“帅”了。
4可能我确实不信任他，怕他走了。或者我其实确实想溜。。。
5不信任，最后司机还是扣了通行证，我也戳了司机的轮胎，这有怎么能是真正的信任呢
仅供参考,不是标准答案
java while loop 编程
测试类：
package test;
public class Lab09f
{
public static void main( String args[] )
{
LetterRemover lr = new LetterRemover();
lr.setRemover("qqqqqqwererrrrrrrrrrrrr", 'r');
System.out.println(lr);
System.out.println(lr.removeLetters());
}
}
方法类：
package test;
public class LetterRemover
{
private String sentence;
private char lookFor;
public LetterRemover()
{
}
public void setRemover(String s, char rem)
{
sentence = s;
lookFor = rem;
}
public String removeLetters()
{
String cleaned=sentence;
int loc = sentence.indexOf(lookFor);
while(loc-1)
{
cleaned=cleaned.substring(0,loc)+cleaned.substring(loc+1);
loc = cleaned.indexOf(lookFor);
}
return cleaned;
}
public String toString()
{
return sentence + " - letter to remove " + lookFor;
}
}
sss框架和hibernate有什么联系
2001年，澳大利亚墨尔本一位名为Gavin King的27岁的程序员，上街买了一本SQL编程的书，他厌倦了实体bean，认为自己可以开发出一个符合对象关系映射理论，并且真正好用的Java持久化层框架，因此他需要先学习一下SQL。这一年的11月，Hibernate的第一个版本发布了。
2002年，已经有人开始关注和使用Hibernate了。
2003年9月，Hibernate开发团队进入JBoss公司，开始全职开发Hibernate，从这个时候开始Hibernate得到了突飞猛进的普及和发展。
2004年，整个Java社区开始从实体bean向Hibernate转移，特别是在Rod Johnson的著作《Expert One-on-One J2EE Development without EJB》出版后，由于这本书以扎实的理论、充分的论据和详实的论述否定了EJB，提出了轻量级敏捷开发理念之后，以Hibernate和Spring为代表的轻量级开源框架开始成为Java世界的主流和事实标准。在2004年Sun领导的J2EE5.0标准制定当中的持久化框架标准正式以Hibernate为蓝本。
2006年，J2EE5.0标准正式发布以后，持久化框架标准Java Persistent API（简称JPA）基本上是参考Hibernate实现的，而Hibernate在3.2版本开始，已经完全兼容JPA标准。[1]
关于lingo，高手请入
model:
sets:
year/1..3/:tsk,tss,tus,usk,uss,uus,vusss,vsssk,vskss,vskus,vssus,wsk,wss,wus,xsk,xss,xus,ysk,yss,yus;
endsets
min=@sum(year(i):Wus(i)+Wss(i)+Wsk(i));
!min=@sum(year(i):400*Vusss(i)+500*Vsssk(i)+200*Wus(i)+500*Wss(i)+500*Wsk(i)+500*Xus(i)+400*Xsk(i)+400*Xss(i)+1500*Yus(i)+2000*Yss(i)+3000*Ysk(i));
0.95*tsk0+0.9*usk(1)+0.95*vsssk(1)-vskus(1)-wss(1)-tss(1)=0;
@for(year(i)|i#gt#1:0.95*tsk(i-1)+0.9*usk(i)+0.95*vsssk(i)-vskus(i)-wss(i)-tss(i)=0);
0.95*Tss0+0.8*Uss(1)+0.95*Vusss(1)-Vsssk(1)+0.5*Vskss(1)-Vssus(1)-Wss(1)-Tss(1)=0;
@for(year(i)|i#gt#1:0.95*Tss(i-1)+0.8*Uss(i)+0.95*Vusss(i)-Vsssk(i)+0.5*Vskss(i)-Vssus(i)-Wss(i)-Tss(i)=0);
0.9*Tus0+0.75*Uus(1)-Vusss(1)+0.5*Vskus(1)+0.5*Vssus(1)-Wus(1)-Tus(1)=0;
@for(year(i)|i#gt#1:0.9*Tus(i-1)+0.75*Uus(i)-Vusss(i)+0.5*Vskus(i)+0.5*Vssus(i)-Wus(i)-Tus(i)=0);
@for(year(i):Vsssk(i)-0.25*Tsk(i)0);
@for(year(i):Ysk(i)+Yss(i)+Yus(i)150);
@for(year(i):Tsk(i)-Ysk(i)-0.5*Xsk(i)=1000);
@for(year(i):Tss(i)-Yss(i)-0.5*Xss(i)=1400);
@for(year(i):Tus(i)-Yus(i)-0.5*Xus(i)=1000);
@for(year(i):Usk(i)500);
@for(year(i):Uss(i)800);
@for(year(i):Uus(i)500);
@for(year(i):Xsk(i)50);
@for(year(i):Xss(i)50);
@for(year(i):Xus(i)50);
@for(year(i):Vusss(i)200);
@for(year:@gin(tsk);@gin(tss);@gin(tus);@gin(usk);@gin(uss);@gin(uus);@gin(vusss);@gin(vsssk);@gin(vskss);@gin(vskus);@gin(vssus);@gin(wsk);@gin(wss);@gin(wus);@gin(xsk);@gin(xss);@gin(xus);@gin(ysk);@gin(yss);@gin(yus));
data:
Tsk0=1000;
Tss0=1500;
Tus0=2000;
enddata
end
sssccc java解析xml字符串
工具类如下 你查考下，单节点的多节点的均可以解析，看不懂在问吧
package bill99;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
public final class XmlUtil {
private Node rootNode;
/**
* 构造方法：解析XML字符串生成根节点
*
* @param xmlStr
*/
public XmlUtil(String xmlStr) {
try {
StringReader sr = new StringReader(xmlStr);
InputSource is = new InputSource(sr);
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
DocumentBuilder builder = factory.newDocumentBuilder();
this.rootNode = builder.parse(is);
} catch (Exception e) {
throw new IllegalArgumentException("xml init error:\n" + xmlStr);
}
}
/**
* 重置根节点
*
* @param rootNode
*/
public void resetRootNode(Node rootNode) {
if (rootNode == null) {
throw new IllegalArgumentException("root node cannot be null");
}
this.rootNode = rootNode;
}
/**
* 检索节点值
*
* @param key
* @return
*/
public String getValue(String key) {
Node node = this.getNode(key);
if (node == null) {
return "";
}
Node temp = node.getFirstChild();
if (null == temp) {
return "";
} else {
return temp.getNodeValue();
}
}
/**
* 检索节点属性
*
* @param key
* @return
*/
public String getProperty(String key) {
if (key == null) {
return "";
}
int index = key.lastIndexOf('.');
String nodeName = key.substring(0, index);
Node node = this.getNode(nodeName);
if (node == null) {
return "";
}
String propertyName = key.substring(index + 1);
NamedNodeMap attrs = node.getAttributes();
Node attr = attrs.getNamedItem(propertyName);
if (attr == null) {
return "";
}
return attr.getNodeValue();
}
/**
* 获取匹配的第一个节点
*
* @param key
* @return
*/
public Node getNode(String key) {
if (key == null) {
return null;
}
Node currentNode = rootNode;
Node preNode = null;
String[] nodeNameArr = key.split("\\.");
for (String nodeName : nodeNameArr) {
preNode = currentNode;
NodeList nodes = currentNode.getChildNodes();
int len = nodes.getLength();
for (int j = 0; j len; j++) {
Node node = nodes.item(j);
if (nodeName.equalsIgnoreCase(node.getNodeName())) {
currentNode = node;
break;
}
}
if (currentNode == preNode) {
return null;
}
}
return currentNode;
}
/**
* 获取匹配的所有节点
*
* @param key
* @return
*/
public ListNode getNodeList(String key) {
ListNode list = new ArrayListNode();
if (key == null || key.trim().length() == 0) {
return list;
}
Node currentNode = rootNode;
Node preNode = null;
String[] nodeNameArr = key.split("\\.");
int count = nodeNameArr.length;
for (int i = 0; i count - 1; i++) {
preNode = currentNode;
NodeList nodes = currentNode.getChildNodes();
int len = nodes.getLength();
for (int j = 0; j len; j++) {
Node node = nodes.item(j);
if (nodeNameArr[i].equalsIgnoreCase(node.getNodeName())) {
currentNode = node;
break;
}
}
if (currentNode == preNode) {
return list;
}
}
NodeList nodes = currentNode.getChildNodes();
int len = nodes.getLength();
for (int j = 0; j len; j++) {
Node node = nodes.item(j);
if (nodeNameArr[count - 1].equalsIgnoreCase(node.getNodeName())) {
list.add(node);
}
}
return list;
}
}