浅谈Spring入门

Spring入门—反射技术

无参数的

Java代码

Class.forName(className).newInstance;     
//有参数的     
Class.forName(className).getDeclaredConstructor(String.class).newInstance(“黎明”);     
//通过反射获取属性     
Introspector.getBeanInfo(Person.class).getPropertyDescriptors()     
//通过反射机制修改bean属性的值     
Person person=(Person)Class.forName(className).getDeclaredConstructor(String.class).newInstance("黎明");     
PropertyDescriptor[] ps = Introspector.getBeanInfo(Person.class).getPropertyDescriptors();     
for(PropertyDescriptor p :ps){     
System.out.println(p.getName());     
if(p.getName().equals("name")){     
Method setter=p.getWriteMethod();     
if(setter!=null){     
setter.setAccessible(true);//允许访问private属性     
setter.invoke(person, "小燕子");     
    
//通过反射机制修改bean字段的值     
Field field=Person.class.getDeclaredField("name");     
field.setAccessible(true);//允许访问private字段     
field.set( person , "sss");

Spring提供了声明式的事务管理

软件的解耦合，不是硬编码

Spring 需要的jar

Dist\spring.jar

lib\jakarta-commons\commons-logging.jar

如果使用了切面编程(AOP),还需要下列jar文件

lib/aspectj/aspectjweaver.jar和aspectjrt.jar   
lib/cglib/cglib-nodep-2.1_3.jar 

如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件

lib\j2ee\common-annotations.jar

配置文件beans.xml

Java代码

 xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> 
 
  <bean id="xx" class="junit.test.Person" lazy-init="true"> 
  bean> 
beans>

怎么启动spring容器Java代码

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

Person s = (Person)context.getBean("xx");



默认bean是容器启动时实例化，只在容器中创建一次，spring中的对象一直存在容器中，是单例模式 

表 3.4. Bean作用域

作用域 描述
singleton 在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype 一个bean定义对应多个对象实例。
request 在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。
session 在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global session 在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。

Spring入门—利用工厂方法创建bean

Java代码

public class PersonFactory {  
 public static Person createPerson(){  
  return new Person();  
 }  
 public Person createPerson2(){  
  return new Person();  
 }  
}

Java代码

//使用静态工厂方法实例化     
<bean id="person" class="bean.PersonFactory" factory-method="createPerson">bean>     
使用实例工厂方法实例化     
<bean id="personFactory" class="bean.PersonFactory">bean>     
 <bean id="person2" factory-bean="personFactory" factory-method="createPerson2">bean>   

Spring入门—依赖注入

Java代码

public class Person {     
    
    private Integer id;     
    private String name="aa";     
    private IDCard idcard;     
         
    public IDCard getIdcard() {     
        return idcard;     
    }     
    
    public void setIdcard(IDCard idcard) {     
        this.idcard = idcard;     
    }     
    
    public Person(String name) {     
        this.name = name;     
    }     
         
    public Person() {     
    }     
    public Integer getId() {     
        return id;     
    }     
    public void setId(Integer id) {     
        this.id = id;     
    }     
    public String getName() {     
        return name;     
    }     
    public void setName(String name) {     
        this.name = name;     
    }     
         
}     
public class IDCard {     
    private String no;     
    
    public String getNo() {     
        return no;     
    }     
    
    public void setNo(String no) {     
        this.no = no;     
    }     
}    

第一种方法
Java代码

<bean id="xx" class="junit.test.Person" lazy-init="true">     
<property name="idcard">     
<bean class="junit.test.IDCard">     
   <property name="no" value="9999">property>     
   bean>     
 property>     
bean>  

第二种方法

Java代码

<bean id="aa" class="junit.test.IDCard">     
<property name="no" value="88888888">property>     
bean>     
 <bean id="xx" class="junit.test.Person" lazy-init="true">     
  <property name="idcard" ref="aa">     
        property>     
  bean>    

为属性配置null值

Java代码

<property name="name"><null/>property>     
    
    
public class Person {     
    private String name="ss";     
public Person(){}     
    public Person(String name) {     
        this.name = name;     
    }     
    public String getName() {     
        return name;     
    }     
    public void setName(String name) {     
        this.name = name;     
    }     
         
    public void say(){     
        System.out.println("我说了");     
    }     
}    

初始化bean执行say方法相当于测试单元的@BeforeClass

<bean id="xxx" class="bean.Person" scope="singleton" lazy-init="false" init-method="say"> 

集合依赖注入

Java代码

<property name="lists">     
         <list>     
            <value>1111value>     
            <value>2222value>     
            <value>3333value>     
            <value>4444value>     
         list>     
property>     
for(String s : p.getLists){     
            System.out.println(s);     
        }     
<property name="sets">     
         <set>     
            <value>TTTvalue>     
            <value>YYYvalue>     
          set>     
property>     
for(String s : p.getSets){     
            System.out.println(s);     
        }     
    
<property name="maps">     
      <map>     
            <entry key="key1" value="value1">entry>     
            <entry key="key2" value="value2">entry>     
       map>     
property>     
for(String key : p.getMaps().keySet()){     
            System.out.println(key+"="+ p. getMaps ().get(key));     
        }     
Properties 是注入     
<property name="propers">     
       <props>     
            <prop key="proper1">value1prop>     
            <prop key="proper2">value2prop>     
       props>     
property>     
for(Object key : p.getPropers().keySet()){     
            System.out.println(key+"="+ p.getPropers().get(key));     
        }  

保护继承与私有继承

一个私有的或保护的派生类不是子类，因为非公共的派生类不能做基类能做的所有的事。例如，下面的代码定义了一个私有继承基类的类：

#include "iostream"
using namespace std;

class Animal
{
public:
Animal(){}

void eat(){cout<<"eat\n";}
};

class Giraffe:protected Animal
{
public:
Giraffe(){}
void StretchNeck(double){
cout<<"stretch neck \n";
}
};

class Cat:public Animal
{
public:
Cat(){}
void Meaw(){
cout<<"meaw\n";
}
};

void Func(Animal& an)
{
an.eat();
}

int main()
{
Cat dao;
Giraffe gir;
Func(dao);
//Func(gir); //error
}


函数Func()要用一个Animal类型的对象， 但调用Func(dao)实际上传递的是Cat类的对象。因为Cat是公共继承Animal类， 所以Cat类对象拥有Animal的所有成员的使用。Animal 对象可以做的事，Cat对象也可以做。 　　但是，对于gir对象就不一样。Giraffe类私有继承了Animal类，意味着对象gir不能直接访问Animal类的成员。其实，在gir对象空间中，包含有Animal类的对象，只是无法让其公开访问。 　　公有继承就像是三口之家的小孩，饱受父母的温暖，享有父母的一切(public和protected的成员)。 其中保护的成员不能被外界所享有，但可以为小孩所拥有。 只是父母还是有其一点点隐私(private成员)不能为小孩所知道。 　 　私有继承就像是离家出走的小孩，一个人在外面飘泊。他(她)不能拥有父母的住房和财产(如：gir.eat()是非法的)， 在外面自然也就不能代表其父母，甚至他(她)不算是其父母的小孩。但是在他(她)的身体中，流淌着父母的血液，所以，在小孩自己的行为中又有其与父母相似 的成分。 　　例如，下面的代码中，Giraffe继承了Animal类，Giraffe的成员函数可以访问像Animal对象那样访问其Animal成员：

#include "iostream"
using namespace std;

class Animal2
{
public:
Animal2(){}
void eat(){ cout <<"eat.\n"; }
};

class Giraffe :private Animal2
{
public:
Giraffe(){}
void StretchNeck(){ cout <<"stretch neck.\n"; }
void take(){ eat(); } //ok
};

void Func(Giraffe & an)
{
an.take();
}

int main()
{
Giraffe gir;
gir.StretchNeck();
Func(gir); //ok
}


运行结果为：

stretch neck．
eat．

　　上例中，gir对象就好比是小孩。eat()成员函数是其父母的行为，take()成员函数是小孩的行为，在该行为中，渗透着父母的行为。但是小孩无法直接使用eat()成员函数，因为，离家出走的他(她)无法拥有其父母的权力。
　　保护继承与私有继承类似，继承之后的类相对于基类来说是独立的；保护继承的类对象，在公开场合同样不能使用基类的成员：

#include "iostream"
using namespace std;
class Animal3
{
public:
Animal3(){}
void eat(){cout<<"eat\n";}
};

class Giraffe:protected Animal3
{
public:
Giraffe(){}
void StretchNeck(){cout<<"stretchneck\n";}
void take()
{
eat(); //ok
}
};

int main()
{
Giraffe gir;
//gir.eat(); //error
gir.take(); //ok
gir.StretchNeck();
}

派生类的三种继承方式小结：
　　公有继承(public)、 私有继承(private)和保护继承(protected)是常用的三种继承方式。
1．对于公有继承方式：
　　·基类成员对其对象的可见性: 与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。这里保护成员与私有成员相同。
　　·基类成员对派生类的可见性: 对派生类来说，基类的公有成员和保护成员可见：基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态；基类的私有成员不可见：基类的私有成员仍然是私有的，派生类不可访问基类中的私有成员。
　　·基类成员对派生类对象的可见性: 对派生类对象来说，基类的公有成员是可见的，其他成员是不可见。
　　所以，在公有继承时，派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。
2．对于私有继承方式：
　　·基类成员对其对象的可见性:与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。
　　·基类成员对派生类的可见性:对派生类来说，基类的公有成员和保护成员是可见的：基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问；基类的私有成员是不可见的：派生类不可访问基类中的私有成员。
　　·基类成员对派生类对象的可见性:对派生类对象来说，基类的所有成员都是不可见的。
　　所以，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。
3．对于保护继承方式：
　　这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言，
　　·基类成员对其对象的可见性: 与一般类及其对象的可见性相同，公有成员可见，其他成员不可见。
　　·基类成员对派生类的可见性: 对派生类来说，基类的公有成员和保护成员是可见的; 基类的公有成员和保护成员都作为派生类的保护成员，并且可以被这个派生类的子类所继承和访问；基类的私有成员是不可见的：派生类不可访问基类中的私有成员。
　　·基类成员对派生类对象的可见性: 对派生类对象来说，基类的所有成员都是不可见的。
　　所以，在保护继承时，基类的成员可以由直接派生类访问，也可以再往下继承。

Eclipse: JVM Terminated. Exit Code=-1 SOLUTION

open eclipse.ini
add a new line if you don't have one
-launcher.XXMaxPermSize
Done.

Notes: someone says add a line
-XX:MaxPermSize=256M
I tried but it didn't work. Maybe it is for the different version.