从应用示例来认识Tiny框架

呵呵,Tiny框架神龙见首不见尾已经许多时间了,里面只看到一些几个孤零零的子框架。今天就通过Tiny开发示例的方式来重点展示一下利用Tiny框架是如何开发的。

HelloWorld

首先从这个神一样的示例写起。

服务开发:

方式1:注解方式

@ServiceComponent()
public class HelloWorldAnnotationService{
	@ServiceMethod(serviceId = "sayHelloA")
	@ServiceResult(name = "result")
	@ServiceViewMapping("/helloworld/helloresult.page")
	public String sayHello(String name) {
		if (name == null) {
			name = "world.";
		}
		return "hello," + name;
	}
}

解释:

@ServiceMethod(serviceId = "sayHelloA")声明服务ID,必须不能重复,保证唯一

@ServiceResult(name = "result")声明返回结果在服务调用完之后旋转在数据总线的名称

@ServiceViewMapping("/helloworld/helloresult.page")声明如果调用服务之后转向的展现页面,可省略

表单输入界面:helloworld.page

服务方式:
<form action="sayHelloA.servicepage">
 输入名称:<input type="text" name="name"/>
 <input type="submit" value="提交"/>
</form>

运行结果界面:

helloresult.page

$!result

方式2:Xml配置方式

public class HelloWorldXmlService{
	public String sayHello(String name) {
		if (name == null) {
			name = "world.";
		}
		return "hello," + name;
	}
}

上面写完类之后,还要再加一个配置文件:

<service-components>
	<service-component type="org.tinygroup.helloworld.service.HelloWorldXmlService"
		group-id="org.tinygroup" artifact-id="helloworldservice">
		<service-method name="sayHello" local-name="sayHello"
			service-id="sayHello" version="" description=""
			method-name="sayHello">
			<service-parameters>
				<service-parameter name="name" type="java.lang.String"
					required="true" is-array="false" />
			</service-parameters>
			<service-result name="result" required="false"
				is-array="false" type="java.lang.String" />
		</service-method>
	</service-component>
</service-components>

这段Xml手工写还是有点麻烦的,不过没关系,咱有工具:

如果想在调用服务之后自动转向到一个页面,则要再配下面的xml

<service-view-mappings>
	<service-view-mapping service-id="sayHello" path="/helloworld/helloresult.page" type="forward"></service-view-mapping>
</service-view-mappings>

表单输入界面:helloworld.page

服务方式:
<form action="sayHello.servicepage">
 输入名称:<input type="text" name="name"/>
 <input type="submit" value="提交"/>
</form>

运行结果界面:

helloresult.page

$!result

方式3:流程编排方式

要通过流程编排方式实现,先要写一个组件:

public class HelloWorldComponent implements ComponentInterface {
	String name;
	String resultKey;
	public String getResultKey() {
		return resultKey;
	}
	public void setResultKey(String resultKey) {
		this.resultKey = resultKey;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void execute(Context context) {
		context.put(resultKey, String.format("Hello, %s", name));
	}
}
写完组件之后,还要编写组件定义文件来定义组件的定义文件,当然要做成组件,就一定要有通用性,这样就可以一次定义,到处使用,对于只用一次的,这么做就不方便了。
<components>
	<component name="helloworld" bean="helloworld"
		title="HelloWorld组件" category="测试组件" icon="/icon/component.gif">
		<short-description>helloworld component</short-description>
		<long-description>helloworld component long description
		</long-description>
		<parameter name="name" title="名字" type="java.lang.String"></parameter>
		<parameter name="resultKey" title="结果键值" type="java.lang.String"></parameter>
	</component>
</components>

OK,现在流程组件就开发完毕了。

就可以像上面一样在可视的流程编辑器中进行可视化开发了。

表单输入页面:

/helloworld.page

流程方式:
<form action="helloworld.pageflow">
 输入名称:<input type="text" name="name"/>
 <input type="submit" value="提交"/>
</form>
运行结果页面:

helloresult.page

$!result

上面的展现简单是简单了点,但是容易理解。

通过上面的HelloWorld,我们对Tiny框架的服务开发及界面开发及控制层的开发都有了一定的了解,下面我们就进入更加复杂一点的示例:

四则运算

由于前面一节已经有了一定了解,因此这一节就只贴代码,解释就省了。

通过注解方式开发服务

@ServiceComponent()
public class FourOperateAnnotationService{
	@ServiceMethod(serviceId = "additionWithAnno")
	@ServiceResult(name = "result")
	@ServiceViewMapping("/fouroperate/result.page")
	public double addition(double number1,double number2){
		return number1+number2;
	}
	@ServiceMethod(serviceId = "subtractWithAnno")
	@ServiceResult(name = "result")
	@ServiceViewMapping("/fouroperate/result.page")
	public double subtraction(double number1,double number2){
		return number1-number2;
	}
	@ServiceMethod(serviceId = "multiWithAnno")
	@ServiceResult(name = "result")
	@ServiceViewMapping("/fouroperate/result.page")
	public double multi(double number1,double number2){
		return number1*number2;
	}
	@ServiceMethod(serviceId = "divisionWithAnno")
	@ServiceResult(name = "result")
	@ServiceViewMapping("/fouroperate/result.page")
	public double division (double number1,double number2){
		return number1/number2;
	}
}

通过Xml配置方式开发服务

public class FourOperateXmlService{
	
	public Double addition(Double number1,Double number2){
		return number1+number2;
	}
	
	public Double subtraction(Double number1,Double number2){
		return number1-number2;
	}
	
	public Double multi(Double number1,Double number2){
		return number1*number2;
	}
	
	public Double division (Double number1,Double number2){
		return number1/number2;
	}
}

通过流程方式开发服务

下面先搞个抽象类:

public  abstract class AbstractFourOperateComponent implements ComponentInterface {
	protected double number1;
	protected double number2;
	protected String resultKey;
	public String getResultKey() {
		return resultKey;
	}
	public void setResultKey(String resultKey) {
		this.resultKey = resultKey;
	}
	public double getNumber1() {
		return number1;
	}
	public void setNumber1(double number1) {
		this.number1 = number1;
	}
	public double getNumber2() {
		return number2;
	}
	public void setNumber2(double number2) {
		this.number2 = number2;
	}
}
接下来就简单了:
public class AdditionComponent extends AbstractFourOperateComponent {

	public void execute(Context context) {
		context.put(resultKey, number1+number2);
	}

}
public class DivisionComponent extends AbstractFourOperateComponent {

	public void execute(Context context) {
		context.put(resultKey, number1/number2);
	}

}
public class MultiComponent extends AbstractFourOperateComponent {

	public void execute(Context context) {
		context.put(resultKey, number1*number2);
	}

}
public class SubtractionComponent extends AbstractFourOperateComponent {

	public void execute(Context context) {
		context.put(resultKey, number1-number2);
	}

}

然后就可以通过编辑器,可视化编辑了。

由于这里主要说明服务端的开发,因此客户端的开发就省略了,其实也是非常简单的。

数据库示例

搞开发,怎么能不搞数据库呢??

下面展现一下数据的开发:

采用Hibernate来开发数据库应用

首先搞个Pojo

public class User {

	private int id;  
    private String name;
    private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
接下来配个hbm文件:
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC   
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="org.tinygroup.crud.pojo">  
    <class name="User" table="user" >  
        <id name="id" >  
            <generator class="native" />  
        </id>  
        <property name="name" />  
        <property name="age" />  
    </class>  
</hibernate-mapping>
再接下来写个Dao:
public class HibernateCrudDao extends HibernateDaoSupport implements CrudDbDao<User>{

	public void addUser(User user) {
          getHibernateTemplate().save(user);		
	}

	public void updateUser(User user) {
		getHibernateTemplate().update(user);
	}

	public void deleteUser(User user) {
		getHibernateTemplate().delete(user);
	}

	@SuppressWarnings("unchecked")
	public List<User> queryUsers(User user) {
		if(user==null){
			return getHibernateTemplate().loadAll(User.class);
		}
		return getHibernateTemplate().findByExample(user);
	}

	public User queryUserById(int id) {
		return (User) getHibernateTemplate().get(User.class, id);
	}

}
接下来实现服务:
@ServiceComponent()
public class HibernateCrudService implements CrudDbService<User> {
	
	private CrudDbDao<User> crudDbDao;
	
	public CrudDbDao<User> getCrudDbDao() {
		return crudDbDao;
	}

	public void setCrudDbDao(CrudDbDao<User> crudDbDao) {
		this.crudDbDao = crudDbDao;
	}
	@ServiceMethod(serviceId = "addUser")
	@ServiceViewMapping(value="/queryUsers.servicepage",type="redirect")
	public void addUser(User user) {
         crudDbDao.addUser(user);
	}
	@ServiceMethod(serviceId = "updateUser")
	@ServiceViewMapping(value="/queryUsers.servicepage",type="redirect")
	public void updateUser(User user) {
         crudDbDao.updateUser(user);
	}
	@ServiceMethod(serviceId = "deleteUser")
	@ServiceViewMapping(value="/queryUsers.servicepage",type="redirect")
	public void deleteUserById(int id) {
		User user=getUserById(id);
		crudDbDao.deleteUser(user);
	}
	@ServiceMethod(serviceId = "queryUsers")
	@ServiceResult(name = "users")
	@ServiceViewMapping("/crud/service/hibernate/list.page")
	public List<User> queryUsers(User user) {
		return crudDbDao.queryUsers(user);
	}
	@ServiceMethod(serviceId = "queryUserById")
	@ServiceResult(name = "user")
	@ServiceViewMapping("/crud/service/hibernate/operate.page")
	public User getUserById(Integer id) {
		if(id==null){
			return null;
		}
		return crudDbDao.queryUserById(id);
	}

}
没错,你看起来这里的服务都是直接调用dao里的方法的,对于这个简单例子看起来有点重复,但是实际应用中是不可能直接把dao发布成服务的,因此你可以想像一下这里有好多步操作就好了。

至此基于Hibernate就可以开发完毕了。

采用TinyDB来实现

TinyDB采用了No Pojo,No Dao的解决方案:

@ServiceComponent()
public class TinyDbCrudService extends BeanSupport implements CrudDbService<Bean>{
	
    private DBOperator operator;
	
	private BeanOperatorManager manager;
	
	private String beanType;
	
	public void setBeanType(String beanType) {
		this.beanType = beanType;
	}

	public void setManager(BeanOperatorManager manager) {
		this.manager = manager;
	}

	 /** 初始化bean。 */
    protected void init() throws Exception {
    	Assert.assertNotNull(manager, "manager must not null");
    	operator=manager.getDbOperator(beanType);
    }
	
	
	@ServiceMethod(serviceId = "addUserTiny")
	@ServiceViewMapping(value="/queryUsersTiny.servicepage?@beantype=user",type="redirect")
	public void addUser(Bean user) {
		operator.insert(user);
	}
	@ServiceMethod(serviceId = "updateUserTiny")
	@ServiceViewMapping(value="/queryUsersTiny.servicepage?@beantype=user",type="redirect")
	public void updateUser(Bean user) {
		operator.update(user);
	}
	@ServiceMethod(serviceId = "deleteUserTiny")
	@ServiceViewMapping(value="/queryUsersTiny.servicepage?@beantype=user",type="redirect")
	public void deleteUserById(int id) {
		operator.deleteById(id);
	}
	@ServiceMethod(serviceId = "queryUsersTiny")
	@ServiceResult(name = "users")
	@ServiceViewMapping("/crud/service/tinydb/list.page")
	public List<Bean> queryUsers(Bean user) {
		if(user==null){
			user=new Bean(beanType);
		}
		Bean[] beans= operator.getBeans(user);
		return Arrays.asList(beans);
	}
	@ServiceMethod(serviceId = "queryUserByIdTiny")
	@ServiceResult(name = "user")
	@ServiceViewMapping("/crud/service/tinydb/operate.page")
	public Bean getUserById(Integer id) {
		if(id==null){
			return null;
		}
		return operator.getBean(id);
	}

}
OK,这样就算完成了。

够简单么??NO,还不够简单。

实际上TinyDB中对于常用的CRUD,根本就不用写代码,框架默认就全部支持了,所以只有复杂的业务逻辑的都需要像上面一样写一下,简单的CRUD,就不用写了。

通过流程方式开发

框架内嵌已经包含了常用的数据库处理组件:

哇,只要拖拖配配就可以了。

页面流

页面流是Tiny框架推荐的控制层解决方案,它强大,简单,可视性好。

呵呵,是不是实现简单,看起来清晰?

当然它的强大在这么简单的例子里是看不到的。

WEB工程

从上面的示例来看,它的界面确实是简单的。然后上面的三个工程最后打了3个Jar包,就算开发完毕了。

在我们的Web工程中,我们要添加这些示例,只要修改pom文件即可:

<dependency>
			<groupId>org.tinygroup</groupId>
			<artifactId>org.tinygroup.helloworld</artifactId>
			<version>1.2.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>org.tinygroup</groupId>
			<artifactId>org.tinygroup.fouroperate</artifactId>
			<version>1.2.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>org.tinygroup</groupId>
			<artifactId>org.tinygroup.crud</artifactId>
			<version>1.2.0-SNAPSHOT</version>
		</dependency>
POM添加了,功能就添加了;POM删除了,功能就删除了,这就是Tiny框架中所说的模块化。

UI引擎

示例完成之后,我对做示例的同学说,你这个示例写得还是可以的,但是我展示的时候很不方便,我要记得每个地址,这对我要求也太高了,能不能给我搞个菜单出来??

此同学说好的,结果他创建了一个default.layout文件,加了如下的代码:

<table border="1" width="100%">
   <tr>
      <td colspan="2">
    helloworld示例:<a href="${TINY_CONTEXT_PATH}/helloworld/helloworld.page">helloworld</a><br/>
          四则运算示例:<a href="${TINY_CONTEXT_PATH}/fouroperate/fouroperate.page">四则运算</a><br/>
          增删改查示例:<a href="${TINY_CONTEXT_PATH}/crud/crud.page">增删改查</a><br/>
      </td>
    </tr>
    <tr>  
      <td width="20%">内容展示</td>
      <td>
         $pageContent
      </td>
   </tr>
</table>
然后我就在访问所有页面的时候都有菜单可用了,这就是TinyUI框架中的装饰。

应用截图

首页:

点击helloworld进入helloworld示例首页

再点下面的服务方式后的helloworld链接

输入abc之后,点提交:

结果就出来了。

下面是数据访问页面:

添加界面:

四则运算界面:

呵呵,不要嫌界面丑,界面丑是因为我不想引入复杂的页面使得注意力转移到其它地方。

总结

上面用了三个例子:HelloWorld,四则运算,数据库访问来对Tiny框架的开发过程进行了展示。当然,Tiny框架提供的实际内容要远远多于你上面看到的内容,比如:

  1. 对页面的局部刷新有强有力的支持,便于进行Ajax处理
  2. 提供Bigpipe模式来提升用户体验
  3. 提供CSS合并、提供JS合并,提供内容压缩输出到浏览器端
  4. 上面开发的所有服务都可以提供xml,json方式结果的返回,也可以通过webservice进行访问
  5. 提供分层部署能力
  6. 提供集群部署支持,接入服务器可以水平进行扩展,应用服务器可以进行水平扩展。

更多内容请看官方网站:www.tinygroup.org


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值