春风博客

买书与读书

书分专业书与闲书.专业书是安身立命之本,建功立业之基,只要对自己有益的,在经济能力能承受的基础上应该多买多看.闲书基本只起业余调剂作用,可看可不看,切勿拿小菜当正餐,过分阅读只有迷惑心智,分散精力的后果.切不可沉迷于其中,所谓玩物丧志是也.

无论钱多寡,买书都应该精挑细选,确实是好书才买,买了坏书或一般书除了浪费钱财,耽误时间,还丧失了读好书的时间和机会,要知道在现在烦杂的社会生活中偷得浮生半日闲也是不容易的,何况以后看见还添堵,与其如此还不如锻炼出鉴别良莠的眼光.

专业书分精品与平装.精品是指那种老外写的,大部头的,全面详细的书,这种书虽贵,但读来收益很大,有微言大义,能常读常新,不像那些国内翻译,改写的,只抄个皮毛,买来如同鸡肋,还不如不买.

看书一定要动笔记点写点什么,所谓"不动笔墨不读书",道理说不上来,但确实有效,写在笔记本或博客都行.闲书可写读后感,锻炼以下文笔也不错.当然看书能把所读熟记于心最好,不要依赖笔记.依赖笔记会养成怠惰的习惯,真要用时一不能立即提出对策,二不一定能找到笔记在那干着急.笔记是用来总结回味的,不是随用随查的电子书籍.

书只能教你知识,不要期待书本或者人能指明你现在该自己干什么,他们只能大致指出一个方向,道还要靠自己去追寻.

posted @ 2007-06-17 22:46 sitinspring 阅读(469) | 评论 (0) | 编辑 收藏

逛技术论坛有嘛用?

posted @ 2007-06-15 12:47 sitinspring 阅读(478) | 评论 (4) | 编辑 收藏

对程序员来说,几种想法最要不得

posted @ 2007-06-14 07:07 sitinspring 阅读(775) | 评论 (6) | 编辑 收藏

在JTable上点击右键并弹出菜单的实现

    String[] headers = {  "No", "Table Name"  };
    Object[][] cellData = null;

    DefaultTableModel model = new DefaultTableModel(cellData, headers) {
      public boolean isCellEditable(int row, int column) {
        // 第N列可以编辑
        /*
         * if (column == N) { return false; }
         */

        // 整个表都不能编辑
        return false;
      }
    };

    table = new JTable(model);

2.菜单的建立
    popupMenu=new JPopupMenu();
   
    tableNameItem=new JMenuItem("");
    selectItem=new JMenuItem("Select SQL");
    insertItem=new JMenuItem("Insert SQL");
    deleteItem=new JMenuItem("Delete SQL");
    updateItem=new JMenuItem("Update SQL");
    hbmItem=new JMenuItem("hbm xml");
    hbmPojoItem=new JMenuItem("Pojo Class");
   
    popupMenu.add(tableNameItem);
    popupMenu.addSeparator();
    popupMenu.add(selectItem);
    popupMenu.add(insertItem);
    popupMenu.add(deleteItem);
    popupMenu.add(updateItem);
    popupMenu.addSeparator();
    popupMenu.add(hbmItem);
    popupMenu.add(hbmPojoItem);

3.菜单的弹出处理
          table.addMouseListener(new MouseAdapter() {
          public void mousePressed(MouseEvent evt) {
              if (evt.isPopupTrigger()) { 
                // 取得右键点击所在行
              int row=evt.getY()/table.getRowHeight();
             
              /**
               * 取得是表名的那一列
               */
              int tableNameColumn=-1;
             
              for(int i=0;i<table.getColumnModel().getColumnCount();i++){
                TableColumn selColumn = table.getColumnModel().getColumn(i);
                String columnHeader=(String)selColumn.getHeaderValue();
               
                if(columnHeader.equals("Table Name")){
                  tableNameColumn=i;
                  break;
                }
              }
             
              /**
               * 取得表名并弹出菜单
               */
              if(tableNameColumn!=-1){
                /**
                 * 修改菜单首条的名称
                 */
                String tableName=(String)table.getValueAt(row,tableNameColumn);
                tableNameItem.setText(tableName);
               
                // 弹出菜单
                popupMenu.show(evt.getComponent(), evt.getX(), evt.getY());
              }
              }
          }
      }
        
4.实现的效果如下:

posted @ 2007-06-12 22:23 sitinspring 阅读(8095) | 评论 (1) | 编辑 收藏

封装完毕,能显示当前时间并改变风格的菜单类

1     JMenuBar menubar = new JMenuBar();
2     mainFrame.setJMenuBar(menubar);
3 
4     
5 
6     TimeMenu timeMenu = new TimeMenu("Time");
7     menubar.add(timeMenu);
8 
9 

posted @ 2007-06-08 01:00 sitinspring 阅读(1915) | 评论 (0) | 编辑 收藏

自己模拟一个Spring的IoC处理

看spring的ioc,感觉很点意思,于是自己写了一个Spring之FileSystemXmlApplicationContext的模拟类,贴出来请大家斧正.

1.功能说明:关于订单,折扣,价格
订单是货物的订单,主要货物有计算机,文具,纸张三类,还有其它一些物件.每种货物都有不同的折扣比例,从单价中扣除折扣比例后就是进货时的真实价格.

2.Spring之Ioc实现

这里就不赘述了,详情请见帖子
http://www.blogjava.net/sitinspring/archive/2007/06/06/122326.html

3.模拟实现

// 折扣接口

public interface Discount{   
 public float getDiscount();   
 public void  setDiscount(float discount);   
}  

// 计算机折扣类
public class ComputerDiscount implements Discount{   
 private float discount=0.0f;   
    
 public float getDiscount(){   
  return discount;   
 }   
    
 public void setDiscount(float discount){   
  this.discount=discount;   
 }   
}  

// 文具折扣类
public class StationaryDiscount implements Discount{   
 private float discount=0.0f;   
    
 public float getDiscount(){   
  return discount;   
 }   
    
 public void setDiscount(float discount){   
  this.discount=discount;   
 }   
}  
// 纸张折扣类

public class PaperDiscount implements Discount{   
 private float discount=0.0f;   
    
 public float getDiscount(){   
  return discount;   
 }   
    
 public void setDiscount(float discount){   
  this.discount=discount;   
 }   
}  
// 其它折扣类

public class OtherDiscount implements Discount{   
 private float discount=0.0f;   
    
 public float getDiscount(){   
  return discount;   
 }   
    
 public void setDiscount(float discount){   
  this.discount=discount;   
 }   
}   

// 订单类
public class Order{   
 public static final String Type_Computer="Computer";   
 public static final String Type_Stationary="Stationary";   
 public static final String Type_Paper="Paper";    
 private String type;   
    
 private float price;    
    
 public Order(float price,String type){   
  this.price=price;   
  this.type=type;   
 }   
    
 public Order(){   
  this(100.0f,"Other");   
 }   
  
  
 // 调用模拟类的地方,看看调用过程和Spring很相似吧 
 public float getPrice() {   
  MockContext ctx = new MockContext("bean.xml");   
  Discount discount = null;   
  discount = (Discount) ctx.getBean(this.type);   
  
  return price * (1.0f - discount.getDiscount());   
 }   
}   
 // Spring之FileSystemXmlApplicationContext的模拟类

/**  
 * Spring之FileSystemXmlApplicationContext的模拟类  
 *   
 * @author junglesong  
 *  
 */  
public class MockContext {   
 Document doc = null;// 用于解析Bean配置文件的Xml Document   
 Element root = null;// Bean文件的根节点   
  
 /**  
  * 构造函数,用于初始化doc和root  
  * @param beanFileName  
  */  
 public MockContext(String beanFileName) {   
  SAXBuilder buider = new SAXBuilder();   
  try {   
   doc = buider.build(new File(beanFileName));   
   root = doc.getRootElement();   
  
  } catch (Exception ex) {   
   ex.printStackTrace();   
  }   
 }   
  
 /**  
  * 根据beanId创建类并调用规定的方法  
  *   
  * @param beanId  
  * @return  
  */  
 public Object getBean(String beanId) {   
  Object obj=null;   
     
  try {   
   Element beanElm =getSubElm(root,"id",beanId);   
      
   if(beanElm!=null){   
    String className=beanElm.getAttribute("class").getValue();   
    Class cls=Class.forName(className);    
    // 由类得到类实例   
    obj=cls.newInstance();   
       
    List ls=beanElm.getChildren();       
    for(Iterator it=ls.iterator();it.hasNext();){   
     Element elm=(Element)it.next();   
        
     String methodName=elm.getAttributeValue("name");   
     String methodValue=(String)elm.getChildText("value");    
        
     // 取得类方法   
     Method method = cls.getMethod(getSetterMethod(methodName), new Class[] {getClassByValue(methodValue)});   
        
     // 建立数组   
                    Object params[]=getParamsByValue(methodValue);   
                                           
                    // 调用类方法   
     method.invoke(obj,params);   
    }       
   }      
  } catch (Exception ex) {   
   ex.printStackTrace();   
  }   
  
  return obj;   
 }   
    
 /**  
  * 由参数的值得到参数的类型,目前可处理浮点数和字符串两种情况  
  *   
  * @param value  
  * @return  
  */  
 private Class getClassByValue(String value){   
  Class cls=String.class;   
     
  try{   
   Float.parseFloat(value);   
   cls=float.class;   
  }   
  catch(Exception ex){   
   ex.printStackTrace();   
  }     
     
  return cls;   
 }   
    
 /**  
  * 由参数的值得到包含参数的数组,目前可处理浮点数和字符串两种情况  
  *   
  * @param value  
  * @return  
  */  
 private Object[] getParamsByValue(String value){   
  Object[] params=new Object[1];   
     
  try{   
   Float.parseFloat(value);   
   params[0]=new Float(Float.parseFloat(value));   
  }   
  catch(Exception ex){   
   ex.printStackTrace();   
   params[0]=new String(value);   
  }    
     
  return params;   
 }   
    
 /**  
  * 取得root下属性为subElmAttr,值等于subElmValue的节点  
  *   
  * @param root  
  * @param subElmAttr  
  * @param subElmValue  
  * @return  
  */  
 private Element getSubElm(Element root,String subElmAttr,String subElmValue){   
  Element rtv=null;   
     
  List ls=root.getChildren();   
     
  for(Iterator it=ls.iterator();it.hasNext();){   
   Element elm=(Element)it.next();   
      
   if(elm.getAttribute(subElmAttr).getValue().equals(subElmValue)){   
    rtv=elm;   
    break;   
   }   
  }   
     
  return rtv;   
 }   
    
 /**  
  * 取得setter方法  
  *   
  * @param methodName  
  * @return  
  */  
 private String getSetterMethod(String methodName){   
  return "set"+methodName.substring(0,1).toUpperCase()+methodName.substring(1,methodName.length());   
 }   
}   
  
 调用的代码如下:

java 代码
Order computerOrder=new Order(100.0f,Order.Type_Computer);   
System.out.println("computerOrder's price is \t"+computerOrder.getPrice());   
  
Order stationaryOrder=new Order(100.0f,Order.Type_Stationary);   
System.out.println("stationaryOrder's price is \t"+stationaryOrder.getPrice());   
  
Order paperOrder=new Order(100.0f,Order.Type_Paper);   
System.out.println("paperOrder's price is \t\t"+paperOrder.getPrice());   
  
Order otherOrder=new Order();   
System.out.println("otherOrder's price is \t\t"+otherOrder.getPrice());  
输出效果和使用Spring是一样的,速度慢了些,但可以优化:

java 代码
computerOrder's price is  70.0  
stationaryOrder's price is  80.0  
paperOrder's price is   90.0  
otherOrder's price is   95.0   

感悟:自己做过一遍后,觉得很多框架并非想像中那样神秘高深,只要肯动脑筋,愿意动手,我们有机会站在时代的风口浪尖上,: ).

posted @ 2007-06-07 15:06 sitinspring 阅读(515) | 评论 (1) | 编辑 收藏