• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

/** *//**获得控制台用户输入的信息
     * @return
     * @throws IOException
     */
    public String getInputMessage() throws IOException...{
        System.out.println("请输入您的命令∶");
        byte buffer[]=new byte[1024];
        int count=System.in.read(buffer);
        char[] ch=new char[count-2];//最后两位为结束符，删去不要
        for(int i=0;i<count-2;i++)
            ch[i]=(char)buffer[i];
        String str=new String(ch);
        return str;
    }

/** *//**以文件流的方式复制文件
     * @param src 文件源目录
     * @param dest 文件目的目录
     * @throws IOException  
     */
    public void copyFile(String src,String dest) throws IOException...{
        FileInputStream in=new FileInputStream(src);
        File file=new File(dest);
        if(!file.exists())
            file.createNewFile();
        FileOutputStream out=new FileOutputStream(file);
        int c;
        byte buffer[]=new byte[1024];
        while((c=in.read(buffer))!=-1)...{
            for(int i=0;i<c;i++)
                out.write(buffer[i]);        
        }
        in.close();
        out.close();
    }

/** *//**
     * 文件输出示例
     */
    public void PrintStreamDemo()...{
        try ...{
            FileOutputStream out=new FileOutputStream("D:/test.txt");
            PrintStream p=new PrintStream(out);
            for(int i=0;i<10;i++)
                p.println("This is "+i+" line");
        } catch (FileNotFoundException e) ...{
            e.printStackTrace();
        }
    }

public void StringBufferDemo() throws IOException......{
        File file=new File("/root/sms.log");
        if(!file.exists())
            file.createNewFile();
        FileOutputStream out=new FileOutputStream(file,true);        
        for(int i=0;i<10000;i++)......{
            StringBuffer sb=new StringBuffer();
            sb.append("这是第"+i+"行:前面介绍的各种方法都不关用,为什么总是奇怪的问题 ");
            out.write(sb.toString().getBytes("utf-8"));
        }        
        out.close();
    }

    /** *//**文件重命名
     * @param path 文件目录
     * @param oldname  原来的文件名
     * @param newname 新文件名
     */
    public void renameFile(String path,String oldname,String newname)...{
        if(!oldname.equals(newname))...{//新的文件名和以前文件名不同时,才有必要进行重命名
            File oldfile=new File(path+"/"+oldname);
            File newfile=new File(path+"/"+newname);
            if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名
                System.out.println(newname+"已经存在！");
            else...{
                oldfile.renameTo(newfile);
            } 
        }         
    }

    /** *//**转移文件目录
     * @param filename 文件名
     * @param oldpath 旧目录
     * @param newpath 新目录
     * @param cover 若新目录下存在和转移文件具有相同文件名的文件时，是否覆盖新目录下文件，cover=true将会覆盖原文件，否则不操作
     */
    public void changeDirectory(String filename,String oldpath,String newpath,boolean cover)...{
        if(!oldpath.equals(newpath))...{
            File oldfile=new File(oldpath+"/"+filename);
            File newfile=new File(newpath+"/"+filename);
            if(newfile.exists())...{//若在待转移目录下，已经存在待转移文件
                if(cover)//覆盖
                    oldfile.renameTo(newfile);
                else
                    System.out.println("在新目录下已经存在："+filename);
            }
            else...{
                oldfile.renameTo(newfile);
            }
        }       
    }

    /** *//**读文件
     * @param path
     * @return
     * @throws IOException
     */
    public String FileInputStreamDemo(String path) throws IOException...{
        File file=new File(path);
        if(!file.exists()||file.isDirectory())
            throw new FileNotFoundException();
        FileInputStream fis=new FileInputStream(file);
        byte[] buf = new byte[1024];
        StringBuffer sb=new StringBuffer();
        while((fis.read(buf))!=-1)...{
            sb.append(new String(buf));    
            buf=new byte[1024];//重新生成，避免和上次读取的数据重复
        }
        return sb.toString();
    }

    /** *//**读文件
     * @param path
     * @return
     * @throws IOException
     */
    public String BufferedReaderDemo(String path) throws IOException...{
        File file=new File(path);
        if(!file.exists()||file.isDirectory())
            throw new FileNotFoundException();
        BufferedReader br=new BufferedReader(new FileReader(file));
        String temp=null;
        StringBuffer sb=new StringBuffer();
        temp=br.readLine();
        while(temp!=null)...{
            sb.append(temp+" ");
            temp=br.readLine();
        }
        return sb.toString();
    }

    /** *//**从目录中读取xml文件
     * @param path 文件目录
     * @return
     * @throws DocumentException
     * @throws IOException
     */
    public Document readXml(String path) throws DocumentException, IOException...{
        File file=new File(path);
        BufferedReader bufferedreader = new BufferedReader(new FileReader(file));
        SAXReader saxreader = new SAXReader();
        Document document = (Document)saxreader.read(bufferedreader);
        bufferedreader.close();
        return document;
    }
 

1.创建文件夹 /** *//**创建文件夹
     * @param path  目录
     */
    public void createDir(String path)...{
        File dir=new File(path);
        if(!dir.exists())
            dir.mkdir();
    }

     * @param path 目录
     * @param filename 文件名
     * @throws IOException
     */
    public void createFile(String path,String filename) throws IOException...{
        File file=new File(path+"/"+filename);
        if(!file.exists())
            file.createNewFile();
    }

/** *//**删除文件

     * @param path 目录
     * @param filename 文件名
     */
    public void delFile(String path,String filename)...{
        File file=new File(path+"/"+filename);
        if(file.exists()&&file.isFile())
            file.delete();
    }

     * @param path
     */
    public void delDir(String path)...{
        File dir=new File(path);
        if(dir.exists())...{
            File[] tmp=dir.listFiles();
            for(int i=0;i<tmp.length;i++)...{
                if(tmp[i].isDirectory())...{
                    delDir(path+"/"+tmp[i].getName());
                }
                else...{
                    tmp[i].delete();
                }
            }
            dir.delete();
        }
    } 

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

# For JBoss: Avoid to setup log4j outside $JBOSS_HOME/server/default/deploy/log4j.xml

# For all other servers: Comment out the Log4J listener in web.xml too

 

log4j.configuration=log4j.properties

 

log4j.rootCategory=info, stdout, logfile

 

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - <%m>%n

 

log4j.appender.logfile=org.apache.log4j.RollingFileAppender

log4j.appender.logfile.File=D:/temp/SpringMVC.log

log4j.appender.logfile.MaxFileSize=512KB

# Keep three backup files

log4j.appender.logfile.MaxBackupIndex=3

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

# Pattern to output: date priority [category] - <message>line_separator

log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - <%m>%n

 

#log4j.logger.com.opensymphony.oscache=ERROR

#log4j.logger.net.sf.navigator=ERROR

#log4j.logger.org.apache.commons=ERROR

#log4j.logger.org.apache.struts=WARN

#log4j.logger.org.displaytag=ERROR

log4j.logger.org.springframework=WARN

#log4j.logger.com.ibatis.db=WARN
 

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

        

   <appender name="ConsoleAppender" class="org.apache.log4j.ConsoleAppender">

     <param name="threshold" value="error"/>

     <layout class="org.apache.log4j. PatternLayout">

       <param name="Conversion" value="%d{(yyyy年MM月dd日-HH時mm分ss秒)} %p [%c] - <%m>%n "/>
</layout>

   </appender>

   

   <appender name="rollingFile.log" class="org.apache.log4j.RollingFileAppender">
     <param name="File" value=" D:/temp/SpringMVC.log " />
<param name="threshold" value="info"/>
     <param name="Append" value="false" />
     <param name="MaxBackupIndex" value="2" />
     <param name="MaxFileSize" value="1024" />
     <layout class="org.apache.log4j.PatternLayout" >
       <param name=" ConversionPattern " value="%d [%t] %p - %m%n" />
     </layout>
    <!-- 实现过滤功能，用这个标签，当往这个指定文件记录日志时只记录指定级别的日志，别的不记录 。
Filter标签只能在xml配置文件好用，在.properties属性文件中不好用-->
<filter class="org.apache.log4j.varia.LevelRangeFilter">
      <param name="LevelMin"      value="ERROR"/>
      <param name="LevelMax"      value="ERROR"/>
      <param name="acceptOnMatch" value="TRUE"/>
    </filter>
   </appender>
<!—封装apache ，这样，可以在java程序中的

Category cat2 = Category.getInstance("your.category.name"); 来进行输出日志-->

<category name="org.apache">      --设置封装的名称

<priority value="info" />     --输出指定级别的日志

<appender-ref ref="aplog"/>   --设置输出的目的地

</category>

<root>

     <level value ="debug" />

     <appender-ref ref="ConsoleAppender"/>

<appender-ref ref=" rollingFile.log "/>  <!--  经过过滤只记录error级别的日志  -->

   </root>

</log4j:configuration>
 

  import org.apache.commons.logging.Log;

   

public class Test{

      public static void main(args[] String){

    Log logger = LogFactory.getLog(“test”);

    logger.info("开始操作");

    int a = 5;

    int b = 6;

    System.out.println(a+b);

    logger.info("操作完毕");

}

}
 

PropertyConfigurator.configure ( String configFilename);

DOMConfigurator.configure ( String filename );

import org.apache.log4j.Logger;

import org.apache.log4j.xml.DOMConfigurator;   

public class Test{

      public static void main(args[] String){

          DOMConfigurator.configure ( String filename )；

          Logger logger = Logger.getRootLogger();

          logger.info("开始操作");

          int a = 5;

          int b = 6;

         System.out.println(a+b);

         logger.info("操作完毕");

}

}
 

     import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.apache.log4j.SimpleLayout;

import org.apache.log4j.FileAppender;

public class simpandfile {

         static Logger logger = Logger.getLogger(simpandfile.class);

         public static void main(String args[]) {

           String pattern =  "Milliseconds since program start: %r %n";

                   pattern += "Classname of caller: %C %n";

                   pattern += "Date in ISO8601 format: %d{ISO8601} %n";

                   pattern += "Location of log event: %l %n";

                   pattern += "Message: %m %n %n"; 

           PatternLayout layout = new PatternLayout(pattern);

           FileAppender appender = null;

             try {

                 appender = new FileAppender(layout,"output1.txt",false);

              } catch(Exception e) {}

              logger.addAppender(appender);

              logger.setLevel((Level) Level.DEBUG);

              logger.debug("Here is some DEBUG");

              logger.info("Here is some INFO");

              logger.warn("Here is some WARN");

              logger.error("Here is some ERROR");

              logger.fatal("Here is some FATAL");

        }

}
 

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

function showJSON() {    
    var user =     
    {     
        "username":"andy",    
        "age":20,    
        "info": { "tel": "123456", "cellphone": "98765"},    
        "address":    
            [    
                {"city":"beijing","postcode":"222333"},    
                {"city":"newyork","postcode":"555666"}    
            ]    
    }    
        
    alert(user.username);    
    alert(user.age);    
    alert(user.info.cellphone);    
    alert(user.address[0].city);    
    alert(user.address[0].postcode);    
}    

function showJSON() {    
    var user =     
    {     
        "username":"andy",    
        "age":20,    
        "info": { "tel": "123456", "cellphone": "98765"},    
        "address":    
            [    
                {"city":"beijing","postcode":"222333"},    
                {"city":"newyork","postcode":"555666"}    
            ]    
    }    
        
    alert(user.username);    
    alert(user.age);    
    alert(user.info.cellphone);    
    alert(user.address[0].city);    
    alert(user.address[0].postcode);    
        
    user.username = "Tom";    
    alert(user.username);    
}    

function showCar() {    
    var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow");    
    alert(carr.toJSONString());    
}    
   
function Car(make, model, year, color)       {    
     this.make  =  make;    
     this.model  =  model;    
     this.year  =  year;    
     this.color  =  color;    
}    

function myEval() {    
    var str = '{ "name": "Violet", "occupation": "character" }';    
    var obj = eval('(' + str + ')');    
    alert(obj.toJSONString());    
}    

function myEval() {    
    var str = '{ "name": "Violet", "occupation": "character" }';    
    var obj = str.parseJSON();    
    alert(obj.toJSONString());    
}    

response.getWriter().print("{ \"name\": \"Violet\", \"occupation\": \"character\" }");  

function sendRequest() {    
    var url = "/MyWebApp/JSONTest1";    
    var mailAjax = new Ajax.Request(    
        url,    
        {    
            method: 'get',    
            onComplete: jsonResponse    
        }    
    );    
}    
   
function jsonResponse(originalRequest) {    
    alert(originalRequest.responseText);    
    var myobj = originalRequest.responseText.parseJSON();    
    alert(myobj.name);    
}    

function jsonResponse(originalRequest) {    
    alert(originalRequest.responseText);    
    var myobj = originalRequest.responseText.evalJSON(true);    
    alert(myobj.name);    
}    

function sendRequest() {    
    var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow");    
    var pars = "car=" + carr.toJSONString();    
   
    var url = "/MyWebApp/JSONTest1";    
    var mailAjax = new Ajax.Request(    
        url,    
        {    
            method: 'get',    
            parameters: pars,    
            onComplete: jsonResponse    
        }    
    );    
}    

private void doService(HttpServletRequest request, HttpServletResponse response) throws IOException {    
        String s3 = request.getParameter("car");    
        try {    
            JSONObject jsonObj = new JSONObject(s3);    
            System.out.println(jsonObj.getString("model"));    
            System.out.println(jsonObj.getInt("year"));    
        } catch (JSONException e) {    
            e.printStackTrace();    
        }    
        response.getWriter().print("{ \"name\": \"Violet\", \"occupation\": \"character\" }");    
    }   

private void doService(HttpServletRequest request, HttpServletResponse response) throws IOException {    
        String s3 = request.getParameter("car");    
        try {    
            JSONObject jsonObj = new JSONObject(s3);    
            System.out.println(jsonObj.getString("model"));    
            System.out.println(jsonObj.getInt("year"));    
        } catch (JSONException e) {    
            e.printStackTrace();    
        }    
            
        JSONObject resultJSON = new JSONObject();    
        try {    
            resultJSON.append("name", "Violet")    
                      .append("occupation", "developer")    
                      .append("age", new Integer(22));    
            System.out.println(resultJSON.toString());    
        } catch (JSONException e) {    
            e.printStackTrace();    
        }    
        response.getWriter().print(resultJSON.toString());    
    }    

function jsonResponse(originalRequest) {    
    alert(originalRequest.responseText);    
    var myobj = originalRequest.responseText.evalJSON(true);    
    alert(myobj.name);    
    alert(myobj.age);    
}   

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mappingResources">
			<list>
				<value>pojo/Euser.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.Oracle9Dialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
			</props>
		</property>
	</bean>

	<bean id="baseDao" class="common.dao.BaseDaoImp">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	
	<bean id="queryDao" class="common.dao.QueryDaoImp">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	
	<bean id="userDAO" class="common.dao.UserDAO">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	
	
	<bean id="pageQueryDao" class="common.dao.PageQueryDaoImp">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<bean name="baseService" class="common.BaseService">
		<property name="baseDao" ref="baseDao" />
		<property name="pageQueryDao" ref="pageQueryDao" />
		<property name="queryDao" ref="queryDao" />
	</bean>

public class BaseService {
    protected BaseDao baseDao;
    protected PageQueryDao pageQueryDao;
    protected QueryDao queryDao;
    
    protected Log log = LogFactory.getLog(getClass());
    /**
     * @param dao
     *            The dao to set.
     */
    public void setBaseDao(BaseDao dao) {
        this.baseDao = dao;
    } 

    public void setPageQueryDao(PageQueryDao pageQueryDao) {
		this.pageQueryDao = pageQueryDao;
	}

	public void setQueryDao(QueryDao queryDao) {
		this.queryDao = queryDao;
	}

}

ApplicationContext context = new ClassPathXmlApplicationContext("xms-web.xml");
	BaseService bs = (BaseService) context.getBean("baseService");
if(baseDao==null){
   System.out.print("==========================");
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

byte b[];
b=groupbean.getAd();
if(b!=null){
	response.setContentType("image/gif");
	javax.servlet.ServletOutputStream sout1=response.getOutputStream();
	try{
		sout1.write(b);
	}
	catch(Exception ex){
		ex.printStackTrace();
	}
	finally{
		sout1.close();
	}
}else{
	System.out.print("adpi---------------null");
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1.我们谈论了J2EE，但究竟什么是J2EE？它是规范吗？它是技术吗？它是在什么样的背景下出现的，为了解决什么？
2.我们也谈架构？但究竟什么是架构？架构出于什么目的？架构的目标是什么呢？
3.我们频繁的使用Struts,但它帮我们解决什么呢？可能有人会说它是MVC的实现，但这不是问题的答案.MVC它又解决了什么呢？

1. J2EE是规范，是一种JSR标准，有详细文档，阐述J2EE提供哪些功能，可以下载这样文档，当然还有一些代码接口，这是典型Java世界中的框架代码+标准文档形式，这是只有自由世界才有的规范，在微软MS世界你是绝对不会看到的，所以，从微软转过来的，会晕，会不适应，不能再按照他们以前的经验来看待自由的新世界。

2.架构是就软件平台的搭建和设计规划，目的是实现软件最大的可维护性和可拓展性，延续软件的生命，就象人生下来，整个架构都有了，虽然一些器官不能用到（例如生殖器官），但是一生下来还是有这些器官，这就是架构设计的优势，没有架构设计的软件是看不到明天，生下的小孩就不会有生殖器官，因为他认为小孩不需要，但是他没有看到小孩20岁以后的未来。

架构就是要有预见性，特别是Java世界，技术流派众多，优劣共存，让人吃药的技术比比皆是，不象微软世界，有微软这个专制强权的架构设计者和提供者告诉你用什么，除此之外别无选择，在Java自由世界，你可能不小心走上一个不归路，软件架构一旦错误，就象出发的方向发生问题，南辕北辙成语就是说这个意思，花再多精力再多钱，再强的人都没有用，项目照样失败。

所以，在Java世界选择技术，就象女孩子到自由市场淘货，必须冒被骗失败的风险，但是其中乐趣也是不言而喻的，你会成为技术专家，当然，如果你想很多找到合适的架构设计，那么借助外力，象J道都提供这样架构设计服务，可以在短时间介绍一些这个自由市场哪些东西是性价比好，值得买，找个有信誉的内行当地人做咨询，就是这个道理。

目前Java世界，架构设计主要是框架选择，如果你的团队非常弱，可能只会基础的Java编程，那么选择强制性框架就比较好，这样可以在保证软件质量情况下，不让不太懂的人胡作非为，破坏软件整体的可维护性，好的框架甚至只需要XML配置就可以，这样，OO能力差一些人，就不需编程代码，配置配置XML就可以，这样，通过架构设计，可以充分发挥现有人员的长处，克服他们的短处。

所以，为什么过去数据库专家DBA年薪20万，而现在架构师年薪20万。而且DBA年薪20万已经成为过去时，因为人们已经发现，再好的数据库设计，只是数据库设计，不是程序语言设计，更多维护烦琐和复杂工作我们是需要修改的程序代码，所以，大家才开始重视应用程序代码，并且发现程序代码控制比数据库设计更难控制，所以有了OO体系专门对付程序代码，进而有了框架，从而诞生比DBA更重要的architect了。

3.关于struts重要性，还是必须从程序代码可维护性来讲，也就是从OO角度讲，Struts能够通过MVC模式将表现层进行细分，实现表现层内部各个细分部分的最大解耦，然后，Struts也可以将页面离散无规律的数据转变为对象，供业务层服务，也就是Struts表现层实际是业务层的服务者，为其提供对象化的枪支弹药，而业务层则可以围绕这些对象实现对象化编程，从而实现更好的可维护性，Evans DDD对业务层进行细分，这些都是基于对象基础，当然持久层不用说，和表现层一样也是业务层的服务者，为其提供对象化的枪支弹药，不过这些对象是从数据库里拿来的，是从一个非对象化，离散的、关系型的数据库拿来的，Hibernate等框架必须将他们转为对象，给业务层使用。

所有这些框架，都是保证我们业务逻辑完全OO，这个前提是：你相信只有OO才是目前实现软件最大维护性和拓展性的适当方式，虽然可能不是最好的，但他是目前最合适的，否则全世界软件工业不会花这么多力气在OO上了。

因为我们国内将软件看成数学，软件论文实际是数学公式论文，可以发生了软件研究方向的偏离，没有走上OO正确研究方向，这样导致很多程序员学校毕业后，根本没有OO基本意识，甚至有人抵触OO，我从出版社内部销售资料看到：Foxpro等数据库书籍名列销售前列，我是欲哭无泪，中国人的软件误区中还要走多少年。

所有这些，必须从我们教育体系寻找，这里面话题太多，我想其中一个问题还是：中微软毒太深，因为微软已经帮你做了架构的事情，你唯一要做的就是拿来某个软件，按照其说明书做，但