#
/**加密
*
*/
public static String doEncrypt(String xmlStr) {
try {
return URLEncoder.encode(xmlStr, "GBK");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return "加密错误";
}
/**
* 解密
* @param saveFile
*/
public static void decrypt(File saveFile) {
try {
BufferedReader reader = null;
reader = new BufferedReader(new FileReader(saveFile));
String tempString = null;
String str2 =null;
while ((tempString = reader.readLine()) != null) {
str2=URLDecoder.decode(tempString);
}
FileOutputStream fos = new FileOutputStream(saveFile);
fos.write(str2.getBytes());
fos.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws UnsupportedEncodingException {
System.out.println(URLDecoder.decode("C:\\Documents and Settings\\chenchangqing\\Desktop\\实物转移_20110824030821.xml", "GBK"));
}
这是把文件内容转换成字符的方式
摘要: 前台：
<form action="uploadimage.jsp" method="post" enctype="multipart/form-data" name="form1">
<input type="file" name="file">
<input type="submit"&n...
阅读全文
区别方法重写（覆盖）和方法重载？
方法重写：方法名字、参数列表和返回类型必须相同。类中只允许出现一次这样的方法，要接着往子类当中写入。类中的方法覆盖，父类和子类都可以相同。
方法重载：方法名字相同，参数列表必须要不同，返回类型随意。构造器就是典型的方法重载。
this和super关键字的用法：this表示的本类的方法和成员；super表示父类的方法和成员。this（）和super（）都必须放在一个方法的开头。
如果子类构造器中没有显式地调用父类构造器，也没有使用this关键字调用重载的其他构造器，则系统默认调用父类无参数的构造器，super（）。
块执行：
在一个类中有初始化块要先执行，然后再是构造器。
如：
public class Test
{
String name;
int age;
String sex;
public Test()
{
System.out.println("Test1被调用");
sex ="Male";
System.out.println("name="+name+" ,age="+age+" ,sex="+sex);
}
public Test(String theName)
{
System.out.println("Test2被调用");
name = theName;
System.out.println("name="+name+" ,age="+age+" ,sex="+sex);
}
{
name = "Tony Blair";
age = 50;
sex = "Female";
System.out.println("Test初始化块执行后：name="+name
+" ,age="+age+" ,sex="+sex);
}
public static void main(String args[])
{
Test t=new Test();
}
}
static关键字可用在变量、方法和内部类中。
在类的定义体中，方法的外部可包含static语句块，在所属的类被载入时执行一次，用于初始化static属性，但不能初始化非静态变量，类变量在整个类中共享。
如：
public class Count {
private int serialNumber;
public static int counter;
static {
System.out.println("static自由块被执行"); //先执行静态块
counter = 1;
}
public static int getTotalCount() {
return counter;
}
public Count() {
counter++;
serialNumber=counter;
}
public static void main(String[] args)
{
System.out.println("main() invoked");
System.out.println("counter = "+Count.counter);
Count t=new Count();
System.out.println("counter = "+Count.counter+" "+t.serialNumber);
}
}
java.lang.Math是一个final类，不可被继承，final变量是引用变量，则不可以改变它的引用对象，但可以改变对象的数据，final方法不可以被覆盖，但可以被重载。
如：
class Aclass
{
int a;
//构造器
public Aclass()
{
a = 100;
}
final public void paint(){
System.out.println("55555555");
}
final public void paint(int i){
System.out.println(i);
}
public void setA(int theA)
{
a = theA;
}
public int getA()
{
return a;
}
}
//定义一个类来测试
public class TestFinal
{
//如果final变量是引用变量，则不可以改变它的引用对象，但可以改变对象的数据
final Aclass REF_VAR=new Aclass();
public static void main(String[] args)
{
TestFinal tf = new TestFinal();
tf.REF_VAR.setA(1);
System.out.println(tf.REF_VAR.getA());
tf.REF_VAR.paint();
tf.REF_VAR.paint(1);
}
}
abstract用在方法或类前。抽象类必须继承，抽象方法必须重写。什么时候用呢？ 当两个类分别有一个公共方法，然后分别继承公共类并完善抽象方法，这样实现一种框架对类起到一个管理的作用。
interface声明方法和变量，特殊抽象类，和类不同的是，一个接口可以继承多个父类接口，多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。
1 . request.setCharacterEncoding("utf-8");
只适合Post方法提交的数据，
2 . 适合用Get方法提交的数据
String name = request.getParameter("name");
name=new String(name.getBytes(“ISO8859_1”),“UTF-8”);
3 .
针对Tomcat服务器，修改server.xml
<Connector port="8083" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
URIEncoding="UTF-8" />
这个只使用GET方法，不适合Post方法
使用JDBC连接SQL SERVER 2008，很多人都在问，我自己也测试几次，发现按照以前的方法连接会出现一点小问题。原因在于，SQL SERVER 2008采用了动态端口的机制，按照以前的方法连接会报告连接不了，其实端口写对了完全没有问题。连接方法如下：
1，微软目前没有发布针对SQL Server 2008专用的JDBC驱动程序，使用SQL Server 2005 的就可以了，但是，需要注意： SQL Server 2008的新功能无法使用，这个必须等专用的JDBC发布之后才能使用。下载地址：
Microsoft SQL Server 2005 JDBC Driver 1.2
http://www.microsoft.com/downloads/details.aspx?displaylang=zh-cn&FamilyID=c47053eb-3b64-4794-950d-81e1ec91c1ba
2，设置端口为固定端口：
SQL Server 配置管理器，按图设置即可
注意：动态端口设为空，即可禁用动态端口
连接的写法：
jdbc:sqlserver://192.168.3.6:1368;databaseName=数据库名称;user=用户名;password=密码
概念：数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不再是重新建立一个连接；释放空闲时间超过最大空闲时间的数据库连接，以避免因为没有释放数据库连接而引起的数据库连接遗漏。
需要注意：
1. 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量数据库连接资源被浪费。
2. 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。
数据库连接池的两个任务：
1. 限制每个应用或系统可以拥有的最大资源，也就是确定连接池的大小（PoolSize）。
2. 在连接池的大小（PoolSize）范围内、最大限度地使用资源，缩短数据库访问的使用周期。
例如： 物理连接数200个，每个连接提供250个Statemet，那么并发的Statement总数为200*250=50000个。
Java开源连接池：
Jakarta DBCP 可直接在应用程序中使用。（比较常用，集成在Tomcat和Struts中）
C3P0是Hibernate的默认数据库连接池。（常用，Hibernate）
其他的还有Proxool、DDConnectionBroker、DBPool、XAPool、Primrose、SmartPool、MiniConnectionPoolManager。
DBCP代码实现：
//创建数据源
public static DataSource setupDataSource(String connectURI) {
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName(org.gjt.mm.mysql.Driver);
ds.setUsername("username");
ds.setPassword("password");
ds.setUrl(connectURI);
return ds;
}
//关闭数据源
public static void shutdownDataSource(DataSource ds) throws SQLException {
BasicDataSource bds = (BasicDataSource)ds;
bds.close();
}
//数据源的使用
DataSource dataSource = getDataSource();
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
pstmt = conn.prepareStatement("select * from users");
rs = pstmt.executeQuery();
while(rs.next()) {
System.out.println(rs.getInt("id"));
}
} catch(Exception e) {
e.printStackTrace();
} finally {
try {
rs.close();
pstmt.close();
conn.close();
} catch(Exception ex) {
ex.printStackTrace();
}
}
在Tomcat中配置数据库连接池：
我们使用Tomcat中lib文件夹下的tomcat-dbcp.jar。
1. 修改server.xml文件在<Service>中写入以下代码:
<Context path="/WebProject" docBase="WebProject" reloadable="true" crossContext="true">
<Resource auth="Container" name="jdbc/CompanyDB" type="javax.sql.DataSource"
factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"
driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
url="jdbc:sqlserver://localhost:1433;DataBaseName=Company"
username="sa"
password="root"
maxActive="100"
maxIdle="30"
maxWait="10000"
removeAbandoned=“true”
removeAbandonedTimeOut="10"
logAbandoned="true"/>
</Context>
path：工程路径。
docBase：工程名字。
name：JNDI的名字。
type：数据源的类。
factory：指定生成的DataReource的factory类名；默认DBCP工厂类。
driverClassName：数据库驱动名。
url：数据库连接的URL。
username：数据库用户名。
password：数据库密码。
maxActive：最大连接数据库数，设为0表示没有限制。
maxIdle：最大等待数量，设为0表示没有限制。
maxWait：最大等待秒数，单位为ms。
removeAbandoned：是否自我中断，默认为false。
removeAbandonedTimeOut：几秒后会自我中断，removeAbandoned必须为true。
logAbandoned：是否记录中断事件，默认为false。
2. 修改web.xml文件，增加一个标签，输入以下代码：
<resource-ref>
<description>Company Connection</description>
<res-ref-name>jdbc/CompanyDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
res-ref-name：指定JNDI的名字。
res-type：指定资源类名。
res-auth：指定资源的Manager。
3. 代码中使用JNDI代码进行获取：
Context ctx = new InitalContext()；
DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/CompanyDB");
Connection conn = ds.getConnection();
注意：java:comp/env/ 是java中JNDI固定写法。
注意：如果该配置出现错误，采用另一种方式进行配置
在tomcat中的server.xml不进行配置，而在context.xml中进行设置
代码如下：
<Resource name="jdbc/CompanyDB" type="javax.sql.DataSource" password="root"
driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver" maxIdle="2" maxWait="5000" username="sa" url="jdbc:sqlserver://localhost:1433;DataBaseName=Company" maxActive="100"/>
web.xml的设置同上一个配置一样。
JSp的session内置对象取值方法
//创建session对象
HttpSession session =requst.getSession();
//设置session 对象的属性值
session.setAttribute("属性名",值);
取值
Object object=session.getAttibute("属性名")
设置方法
//设置响应回去的类型
response.setContentType("text/html");
//设置响应的字符编码格式
response.setCharacterEncoding("UTF-8");
request(请求)
//获取请求属性的值
request.getParameter("属性名");
多用于表单提交和URL参数的传递的取值
JSp内置对象生命周期：
out 只在本jsp页面使用 无生命周期
request 生命周期 一次请求
response 生命周期 一次响应
session 生命周期 项目浏览器关闭时，生全周期结束，默认不操作项目超过30分钟生命周期结束
application 生命周期 当开启Tomcat服务器时创建，关闭Tomcat服务器时结束生命周期 (作用：统计服务器访问人数或流量)
页面跳转:
response.sendRedirect("admin/one.jsp") 重定向
RequestDispatcher 请求跳转
两者实现的效果相同
二者的区别：
1、
URL 地址的变化用response.sendRedirect时，RequestDi.spatcher不会使URL地址进行变化。
RepuestDispatcher 是服务器端请求机制的跳转
response.sendRedirect 是客户端请求机制的重定向
2、
RequestDispatcher传值通过JSP-Servlet-JSp形式直接传入到下一个JSp页面
response.sendRedirect 传值通过JSP-Servlet-JSP形式，只能够传递到请求机制重定向这之前
3、
如果项目要跳转到另外一个服务器的页面时，用response.sendRedirect进行重定向
4、
我们尽量使用RequestDispatcher方式，因为是服务器响应，所以在web容器执行效率较高
RequestDispatcher什么时候使用呢？
项目中不进行页面的交互跳转的时候，例如一个界面的增、删、改、查，或者相关联同类型模块之间的跳转
response.sendRedirect重定向什么时候使用呢？
无关联的不同模块间跳转使用，例如，用户界面模块跳转到产品信息界面模块
5、
RequestDispatcher基本上认定使用在Servlet里面
response.sendRedirect 用在Servlet和JSP页面较多
重定向传值 只影响request，不影响session的传值
session何时使用?
传值时尽量不要使用session
购物车的实现必须使用session对象
session.removeAttribute("name") 全部删除物品
如果选择性删除？
传入要删除的购物信息主键id值，根据id值支查找集合中的对应信息，然后做集合中的删除操作
for(Product product : list){
if(deleteid==product.getid()){
list.remove(product);
}
}
session.setAttribute("gouwu",list)
两种提交方式的乱码处理：
post提交方式乱码处理
中文乱码问题
request.setcharacterEncoding("UTF-8");
处理get方式提交的乱码方式处理
String names=new String(request.getParameter("name").getBytes("ISO-8859-1"),"UTF-8")
DAO程序设计
在用DAO设计模式编写程序时，根据以下几个步骤：
1、定义接口；
2、定义底层JavaBean；
3、数据库连接；
4、实现接口；
5、工厂；
6、主函数；
根据你的项目，在不同的包里面写相应的代码！
下面是一个简单的例子：
1、定义接口：
package com.qhit.s2.t13.dao;
import java.util.List;
import com.qhit.s2.t13.javaben.User;
public interface IUserDAO {
public List<User> findAll();
}
2、JavaBean：
package com.qhit.s2.t13.javaben;
public class User {
private Integer id;
private String username;
private String password;
public User() {
super();
}
public User(Integer id, String username, String password) {
super();
this.id = id;
this.username = username;
this.password = password;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
3、数据库连接：
package com.qhit.s2.t13.dao.impl;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBConnection {
private java.sql.Connection conn = null;
// public final static String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
// public final static String URL = "jdbc:sqlserver://localhost:1433;DataBaseName=Company";
// public final static String DBUSER = "sa";
// public final static String DBPASS = "root";
public java.sql.Connection getConnection() {
try {
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
conn = DriverManager.getConnection(
"jdbc:sqlserver://localhost:1433;DataBaseName=Company",
"sa", "root");
return conn;
} catch(Exception e) {
e.printStackTrace();
}
return null;
}
public void closeConnection() {
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
4、实现接口：
package com.qhit.s2.t13.dao.impl;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.qhit.s2.t13.dao.IUserDAO;
import com.qhit.s2.t13.javaben.User;
public class UserDAOImpl implements IUserDAO {
public List<User> findAll() {
List<User> userList = new ArrayList<User>();
String sql = "select * from users";
DBConnection db = new DBConnection();
try {
// System.out.println(db.getConnection());
PreparedStatement ps = db.getConnection().prepareStatement(sql);
ResultSet rs = ps.executeQuery();
if(rs != null) {
while(rs.next()) {
User user = new User();
user.setId(rs.getInt("id"));
user.setUsername(rs.getString("userName"));
user.setPassword(rs.getString("password"));
userList.add(user);
}
}
rs.close();
ps.close();
db.closeConnection();
return userList;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
}
5、工厂
package com.qhit.s2.t13.dao.impl;
import com.qhit.s2.t13.dao.IUserDAO;
public class DAOFactory {
public static IUserDAO getUserDAO() {
return new UserDAOImpl();
}
}
6、主函数：
package main;
import java.util.List;
import com.qhit.s2.t13.dao.impl.DAOFactory;
import com.qhit.s2.t13.javaben.User;
public class TestMain {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<User> list = DAOFactory.getUserDAO().findAll();
if(list != null) {
System.out.println("chenggong");
} else {
System.out.println("shipai");
}
}
}