Jfire-Core 框架API文档

Jfire-Core框架

框架优势

快速入门

package com.jfire.core
@Resource("person")
public class Person
{
private String name;
@Resource//通过注解，将home对象的实例注入到person对象的实例中
private Home home;
}
@Resource
public class Home
{
private String name;
@Resource
private Address add
}
public class Address
{
private string location;
private int num;
}
public static void main(String args[])
{
//给定扫描的包路径，注解了Resource的都会被识别为Bean
JfireContext context = new JfireContextImpl("com.jfire.core");
//手动增加一个bean到容器，并且设置该bean的名称，是否单例，bean使用的类
context.addBean(Address.class.getName(),false,Address.class);
//使用给定的参数进行容器初始化
context.init();
//通过类获取一个类在容器中的实例。该类被注解为单例
Person person = context.getBean(Person.class);
//也可以通过给类设定的bean名称获取到类实例
Person person2 = context.getBean("person");
Home home = person.getHome();
}

代码信息

IOC容器

定义Bean

注解方式定义bean

Resource

Resource

name

shareable

name

shareable

使用配置文件指定一个类为bean

{
"beans":
[
{
"beanName": "com.jfire.core.test.function.base.data.House",//bean的名称
"prototype": false,//bean是否是原型。原型就是非单例
"className": "com.jfire.core.test.function.base.data.House"//bean的类的全限定名
}
]
}

通过JfireContext直接将一个对象制定为bean并且加入

jfireContext.addSingletonEntity("User",new User());//往容器中添加一个名称为User的bean，并且该bean是单例，容器中存储着设置进入的单例供其他类使用

通过配置文件指定一个类成为bean

"beans": [
{
"beanName": "com.jfire.core.test.function.base.data.House",//定义bean的名称
"prototype": false,//定义bean是否是原型。原型表示非单例
"className": "com.jfire.core.test.function.base.data.House"//bean的全限定名
}
]

容器发现bean

通过扫描包路径，自动发现bean

resource

jfireContext.addPackageNames("com.jfire.core","com.test.entity")

{"packageNames" : ["com.jfire.core.test.function.base","com.test"]}

手动添加一个类到容器

resource

jfireContext.addBean(User.class)

resource

resource

jfireContext.addBean(House.class.getName(), false, House.class)

增加一个外部对象实例到容器

jfireContext.addSingletonEntity("userBean",new User())

依赖注入

普通类型注入

resource

public class Person
{
@Resource //在这里打上注解表示会将bean名称是"com.test.Home"的bean实例注入到这个属性中。
private com.test.Home home;
@Resource("home1")//这样表示会将bean名称是"home1"的bean注入到这个属性中
private Home home;
}

Resource

Resource

通过配置文件进行依赖注入

@Resource("Per")
public class Person
{
}
public class House
{
private Person person;
}

{
"beanConfigs":
[
{
"beanName": "p2",
"dependencies"://表示house这个bean中有什么属性需要进行依赖注入
{
"person":"Per"//每一个键值对都是一个依赖注入。key代表被注入的属性的名称，value表示注入的bean的名称
}
}
],
"beans":
[
{
"beanName": "com.jfire.core.test.function.base.data.House",//定义bean的名称
"prototype": false,//定义bean是否是原型。原型表示非单例
"className":"com.jfire.core.test.function.base.data.House",
"dependencies"://表示house这个bean中有什么属性需要进行依赖注入
{
"person":"Per"//每一个键值对都是一个依赖注入。key代表被注入的属性的名称，value表示注入的bean的名称
}
}
]
}

List类型注入

List<T>

public interface Person
{
public String name();
public int age();
}
@Resource
public class Teacher implements Person
{
}
@Resource
public class Student implements Person
{
}
public class Home
{
@Resource//这样的话，实现了接口Person的bean都会被注入到这个list中,但是这个list是需要实现存在的。
private List<Person> pers = new ArrayList();;
}

通过配置进行List注入

"beans":
[
{
"beanName": "com.jfire.core.test.function.base.data.House",//定义bean的名称                       "prototype": false,//定义bean是否是原型。原型表示非单例
"className": "com.jfire.core.test.function.base.data.House"//bean的全限定名
"dependencies"://表示house这个bean中有什么属性需要进行依赖注入
{
"person":"Per1;Per2;Per3"//每一个键值对都是一个依赖注入。key代表被注入的属性的名称，value表示注入的bean的名称并且采用;号分割每一个被注入的bean名称
}
}
]

Map注入

@Resource
public interface Order{}

public class Order1 implements Order
{
public String keyName();
}
@Resource
public class Order2 implements Order
{
public String keyName();
}
@Resource
public class MapEntity
{
@Resource//实现了接口Order的bean都会被注入
@Mapkey("keyName")//所有被注入的bean都有一个无参的keyName方法，使用该方法返回值作为该bean的key
private Map<String,Order> map = new Hashmap();
}

Resource

MapKey

MapKey

通过配置文件进行Map注入

:

:

|

:

"beanConfigs":
[
{
"beanName": "house",
"dependencies":
{
"map": "p1:person1|p2:person2"
}
}
]

设定bean的初始化方法

InitMethod

@Resource
public class Person
{
@InitMethod
public void say(){
System.out.println("你好");
}
public static void main(String args[])
{
JfireContext context = new JfireContextImpl("com.test");
context.getBean(Person.class);//获取到bean的时候就会调用被InitMethod注解了的方法。这里是调用say方法。
}
}

通过配置文件设定bean的初始化方法

{
"beanConfigs": [
{
"beanName": "p2",
"initMethods": [//配置initMethods的信息。内容就是方法的名称
"initage"
]
}
]
}

容器初始化结束接口

public interface ContextInitFinish extends Order
{
/**
* 当容器初始化完成后，该接口会被容器调用
*
* @author 林斌(eric@jfire.cn)
*/
public void afterContextInit();
}

order

afterContextInit

参数注入

"beanConfigs": //对bean进行配置
[
{
"beanName": "com.entity.Person", //指定要配置的bean的名称
"params": //对bean进行参数注入。
{
"name": "test",
"age": "19",
"hasHome": "false"
}
}
]

params

"attribute":
{
"params":
{
"name": "林斌",
"age": "25",
"boy": "true",
"arrays":"12,123,1234"
}
}

完整配置文件

beanConfigs

attributes

{
"packageNames": //指定要扫描的包路径。会检索该路径和子路径下的所有类
[
"com.jfire.core.test.function.base",
"cn.starnet.entity"
],
"beanConfigs": //对已经在容器中的bean进行额外信息配置
[
{
"beanName": "com.entity.Person", //指定要配置的bean的名称，这里的bean是已经在容器中存在的
"params": //配置该bean的参数注入
{
"name": "test",
"age": "19",
"hasHome": "false"
},
"dependencies": //配置该bean的依赖注入
{
"home": "com.test.Home",
"address": "com.test.Address"
},
"initMethods": //配置该bean的初始化方法
[
"say",
"initCall"
]
}
],
"beans": [//配置要加入到容器的bean的信息，基础的包括bean名称，bean是否单例，bean的类的全限定名
{
"beanName": "com.jfire.core.test.function.base.data.House",//bean的名称
"prototype": false,//bean是否原型。原型就是非单例
"className": "com.jfire.core.test.function.base.data.House"//bean使用的类的全限定名
},
{
"beanName": "com.jfire.core.test.function.base.data.ImmutablePerson",
"prototype": false,
"className": "com.jfire.core.test.function.base.data.ImmutablePerson",
"params": //配置该bean的参数注入
{
"name": "test",
"age": "25",
"boy": "true"
},
"dependencies": //配置该bean的依赖注入
{
"home": "com.test.Home",
"address": "com.test.Address"
},
"initMethods": //配置该bean的初始化方法
[
"say",
"initCall"
]
}
]
}

AOP功能

//这个注解表明这个bean是一个AOP增强类。它的值是被织入（被增强，目标 类等都是一个意思的名称）类的类全限定名。这个表达式支持通配符`*`。 * 该符号表示任意长度的任意字符
@EnhanceClass("com.test.*.Action.*")
@Resource//这个注解让框架可以发现这个AOP类
public class Aop
{
@BeofreEnhance(value="before()",order=1)//这个是一个前置拦截，表示要拦截的方法的名称是before，没有入参，order属性用于排序，如果有多个拦截方法同时对一个方法进行拦截。使用自然顺序进行排序
public void before(ProceedPoint point){}
}

EnhanceClass

value

*

com.test.*Action

com.test.UserAction

getName()

()

()

setName(String int)

setName(java.util.String int)

(*)

getName(*)

int[][]

com.jfire.core.aop.ProceedPoint

ProceedPoint.getHost()

ProceedPoint.getParam()

ProceedPoint.getResult()

ProceedPoint.setResult(Object invokedResult)

前置增强

@BeforeEnhance

ProceedPoint.setPermission(boolean)

ProceedPoint.setResult(Object)

后置增强

AfterEnhance

ProceedPoint.getResult()

ProceedPoint.setResult(Object invokedResult)

异常增强

ThrowEnhance

type

Throwable

环绕增强

AroundEnhance

ProceedPoint.invoke()

ProceedPoint.invoke()

ProceedPoint.setResult(Object invokedResult)