manyinjin
- 浏览: 92227 次
- 性别:
- 来自: 北京
-
最新评论
-
ocaicai：
感谢》》》》》》》》》》》》》》》
json-lib 的maven dependency -
nba：
原来是这个问题导致, 十分感谢
json-lib 的maven dependency -
Navee：
不错，加个<classifier>jdk15< ...
json-lib 的maven dependency -
P05004260：
给跪了……谢谢……
json-lib 的maven dependency -
csc365kl：
没有学习曲线太假了！！！
被Groovy震的第一下
呵呵，下面这段代码，看起来很眼熟吧？猜猜输出的是什么？
println new URL("http://manyinjin.iteye.com").openConnection().getInputStream().getText();
简单的一行语句，blog里面的东西都print了，重要的是，我只需要知道java里怎么做就行了。。。
你甚至可以这样：
public class Person{
String name;
String idCard;
}
Person p = new Person(name:"manyinjin", idCard:"my idcard #");
println p.getAt("name");
println p.getName();
没有学习曲线，和java完全交融，在享受java强大的服务器端技术的同时也简化了语法和显著减少了代码行数，pretty cool!
分享到：
评论
16 楼
Bernard
2009-03-21
night_stalker 写道
Bernard 写道
就算是动态语言也应该有一套严格的语法。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
groovy保持java的样子，模仿动态语言语法，同时也包装了一些java hack……
虽说编译成静态，但是动态语法大量使用反射泛型和动态代理和动态装载，速度比正常java慢很多，与解释执行相比也体现不出编译的效率优势。
看看《java解惑》，java里令人抓狂的陷阱也不少。
日常说话聊天比动态语言灵活多了，也无所适从么？
你的日常用语很好么，怎么让人觉得这么反感。
15 楼
jingyukxy
2009-03-20
package com.lab.eqpt.web.admin;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springside.core.web.StrutsEntityAction;
import com.common.UC2GB;
import com.common.UtilDao;
import com.common.Utils;
import com.lab.eqpt.service.EqptBookManager;
import com.lab.eqpt.service.EqptBookTaskManager;
import com.lab.model.CodeBookStep;
import com.lab.model.EqptBook;
import com.lab.model.EqptBookApproveTime;
import com.lab.model.EqptBookBookTime;
import com.lab.model.EqptBookFinalTime;
import com.lab.model.EqptBookTime;
import com.lab.model.EqptUseRecord;
import com.lab.model.InfoGuideFile;
import com.lab.model.ScLoginUser;
public class EqptBookInfoStatisticsAction extends StrutsEntityAction<EqptBook, EqptBookManager>{
private EqptBookManager eqptBookManager;
private EqptBookTaskManager eqptBookTaskManager;
public void setEqptBookTaskManager(EqptBookTaskManager eqptBookTaskManager){
this.eqptBookTaskManager = eqptBookTaskManager;
}
public void setEqptBookManager(EqptBookManager eqptBookManager) {
this.eqptBookManager = eqptBookManager;
}
protected void onInitForm(ActionForm form,
HttpServletRequest request,EqptBook eqptBook)
{
String bookMan = request.getParameter("bookMan");
String taskFlag = request.getParameter("taskFlag");
if (Utils.isNotEmpty(bookMan))request.setAttribute("bookMan",bookMan);
if (eqptBook.getEqptBookBookTimes() != null)
{
Iterator it = eqptBook.getEqptBookBookTimes().iterator();
if(it.hasNext())
{
EqptBookBookTime eqptBookBookTime = (EqptBookBookTime)it.next();
request.setAttribute("eqptBookBookTimes", eqptBookBookTime);
}
}
EqptBookApproveTime eqptBookApproveTime = null;
EqptBookFinalTime eqptBookFinalTime = null;
if(eqptBook.getEqptBookFinalTimes()!=null)
{
//向页面传值
List bookTimes = new ArrayList();
for(Iterator iter = eqptBook.getEqptBookFinalTimes().iterator(); iter.hasNext();)
{
EqptBookFinalTime bookFinalTime = (EqptBookFinalTime)iter.next();
String startTime = Utils.getFmtDate(bookFinalTime.getStartTime(), "yyyy-MM-dd HH:mm");
String endTime = Utils.getFmtDate(bookFinalTime.getEndTime(), "yyyy-MM-dd HH:mm");
EqptBookTime eqptBookTime = new EqptBookTime();
eqptBookTime.setFinFlag(bookFinalTime.getFinFlag());
eqptBookTime.setDate(startTime.substring(0,11));
eqptBookTime.setStartHour(startTime.substring(11,13));
eqptBookTime.setStartMinute(startTime.substring(startTime.length()-2));
eqptBookTime.setEndHour(endTime.substring(11,13));
eqptBookTime.setEndMinute(endTime.substring(startTime.length()-2));
bookTimes.add(eqptBookTime);
}
request.setAttribute("bookTimes", bookTimes);
}
//多时间段取值
List eqptBookFinalTimes = new ArrayList();
if(eqptBookFinalTime==null&&eqptBook.getEqptBookApproveTimes() != null)
{
for(Iterator iter1=eqptBook.getEqptBookApproveTimes().iterator(); iter1.hasNext();) {
eqptBookApproveTime = (EqptBookApproveTime)iter1.next();
eqptBookFinalTime = new EqptBookFinalTime();
eqptBookFinalTime.setStartTime(eqptBookApproveTime.getStartTime());
eqptBookFinalTime.setEndTime(eqptBookApproveTime.getEndTime());
eqptBookFinalTimes.add(eqptBookFinalTime);
}
}
String[] fileNames = null;
String[] fileUrls = null;
ArrayList<InfoGuideFile> reportGuideFiles = new ArrayList<InfoGuideFile>();
EqptUseRecord eqptUseRecord = null;
if(eqptBook.getEqptUseRecords()!=null)
{
//向页面传值
List bookTimes = new ArrayList();
for(Iterator iter = eqptBook.getEqptBookFinalTimes().iterator(); iter.hasNext();)
{
EqptBookFinalTime bookFinalTime = (EqptBookFinalTime)iter.next();
String startTime = Utils.getFmtDate(bookFinalTime.getStartTime(), "yyyy-MM-dd HH:mm");
String endTime = Utils.getFmtDate(bookFinalTime.getEndTime(), "yyyy-MM-dd HH:mm");
EqptBookTime eqptBookTime = new EqptBookTime();
eqptBookTime.setFinFlag(bookFinalTime.getFinFlag());
eqptBookTime.setDate(startTime.substring(0,11));
eqptBookTime.setStartHour(startTime.substring(11,13));
eqptBookTime.setStartMinute(startTime.substring(startTime.length()-2));
eqptBookTime.setEndHour(endTime.substring(11,13));
eqptBookTime.setEndMinute(endTime.substring(startTime.length()-2));
bookTimes.add(eqptBookTime);
}
request.setAttribute("bookTimes", bookTimes);
Iterator i = eqptBook.getEqptUseRecords().iterator();
if(i.hasNext())
{
eqptUseRecord = (EqptUseRecord)i.next();
Date enterDate = eqptUseRecord.getEnterDate();
Date today = new Date();
if(((today.getTime() - enterDate.getTime())/(60L*60L*24L*1000L)) > 15)
{
request.setAttribute("expired", 1);
}
request.setAttribute("eqptUseRecordForm", eqptUseRecord);
if(Utils.isNotEmpty(eqptUseRecord.getReport())&&Utils.isNotEmpty(eqptUseRecord.getReporturl()))
{
fileNames = eqptUseRecord.getReport().split(",");
fileUrls = eqptUseRecord.getReporturl().split(",");
for(int j = 0;j < fileNames.length;j++)
{
InfoGuideFile reportGuideFile = new InfoGuideFile();
reportGuideFile.setFileName(fileNames[j]);
reportGuideFile.setFileUrl(fileUrls[j]);
reportGuideFiles.add(reportGuideFile);
}
}
}
}
if(eqptUseRecord==null)
{
//向页面传值
List bookTimes = new ArrayList();
for(Iterator iter = eqptBookFinalTimes.iterator(); iter.hasNext();)
{
EqptBookFinalTime bookFinalTime = (EqptBookFinalTime)iter.next();
String startTime = Utils.getFmtDate(bookFinalTime.getStartTime(), "yyyy-MM-dd HH:mm");
String endTime = Utils.getFmtDate(bookFinalTime.getEndTime(), "yyyy-MM-dd HH:mm");
EqptBookTime eqptBookTime = new EqptBookTime();
eqptBookTime.setFinFlag(bookFinalTime.getFinFlag());
eqptBookTime.setDate(startTime.substring(0,11));
eqptBookTime.setStartHour(startTime.substring(11,13));
eqptBookTime.setStartMinute(startTime.substring(startTime.length()-2));
eqptBookTime.setEndHour(endTime.substring(11,13));
eqptBookTime.setEndMinute(endTime.substring(startTime.length()-2));
bookTimes.add(eqptBookTime);
}
request.setAttribute("bookTimes", bookTimes);
eqptUseRecord = new EqptUseRecord();
eqptUseRecord.setSelfFee(new Double(0));
eqptUseRecord.setExtFee(new Double(0));
request.setAttribute("eqptUseRecordForm", eqptUseRecord);
}
request.setAttribute("taskFlag", taskFlag);
request.setAttribute("reportGuideFiles", reportGuideFiles);
}
@SuppressWarnings("unchecked")
public ActionForward saveEqptBook(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
{
ScLoginUser scLoginUser = (ScLoginUser)request.getSession().getAttribute("loginUser");
String bookId = request.getParameter("bookId");
String step = request.getParameter("step");
UtilDao utilDao = (UtilDao) WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext()).getBean("utilDao");
utilDao.deleteRecord("eqpt_book_final_time", "book_id",bookId);
EqptBook eqptBook = eqptBookManager.get(EqptBook.class,bookId);
//处理完成登记
Enumeration enu = request.getParameterNames();
int temp=0, len=0;
while(enu.hasMoreElements()) {
String condition = String.valueOf(enu.nextElement());
if(condition.startsWith("t_")) {
temp = Integer.parseInt(condition.substring(condition.length()-1));
}
if(temp > len) {
len = temp;
}
}
String recordId = request.getParameter("t_recordId1");
String testUserName = "";
String enterName = "";
for(int i=1; i<=len; i++) {
String startDate = request.getParameter("t_startDate"+i);
String endDate = request.getParameter("t_endDate"+i);
String startHour = request.getParameter("t_startHour"+i);
String startMinute = request.getParameter("t_startMinute"+i);
String endHour = request.getParameter("t_endHour"+i);
String endMinute = request.getParameter("t_endMinute"+i);
Date startTime = Utils.getDate(startDate,startHour,startMinute);
Date endTime = Utils.getDate(startDate, endHour, endMinute);
testUserName += request.getParameter("t_testUserName"+i) + ",";
if(startTime != null && endTime !=null) {
EqptBookFinalTime eqptBookFinalTime = new EqptBookFinalTime();
if(step.equals("3")) eqptBookFinalTime.setFinFlag(Long.valueOf(1));
eqptBookFinalTime.setEndTime(endTime);
eqptBookFinalTime.setStartTime(startTime);
eqptBookFinalTime.setEqptBook(eqptBook);
eqptBook.getEqptBookFinalTimes().add(eqptBookFinalTime);
}
enterName = request.getParameter("t_enterName"+i);
}
//添加使用记录
EqptUseRecord eqptUseRecord = new EqptUseRecord();
if(Utils.isNotEmpty(recordId))
{
eqptUseRecord = this.eqptBookManager.get(EqptUseRecord.class, recordId);
}
eqptUseRecord.setTestUserName(testUserName);
////文件上传处理
String[] del_id = request.getParameterValues("del_id");
deleteFile(eqptUseRecord,del_id, request.getRealPath(""));// 1.首先删除磁盘文件
String path = "/uploads/report/";
String fileNames = eqptUseRecord.getReport();
String fileUrls = eqptUseRecord.getReporturl();
String file_num = request.getParameter("file_num");
if (file_num != null)
{
if(Utils.isEmpty(fileNames))
{
fileNames = "";
}
if(Utils.isEmpty(fileUrls))
{
fileUrls = "";
}
for (int i = 1; i <= Integer.parseInt(file_num); i++)
{
String reportFile[] = uploadFile(form, request, "attachfile" + i,path);
if (reportFile != null)
{
fileNames += reportFile[0]+",";
fileUrls += path + reportFile[1]+",";
}
}
}
eqptUseRecord.setReport(fileNames);
eqptUseRecord.setReporturl(fileUrls);
///////////////////////////////////////////////////////////////////////
String memo = request.getParameter("memo");
eqptUseRecord.setMemo(memo);
String selfFeeStr = request.getParameter("selfFee");
if(!Utils.isNotEmpty(selfFeeStr))
{
selfFeeStr = "0";
}
String extFeeStr = request.getParameter("extFee");
if(!Utils.isNotEmpty(extFeeStr))
{
extFeeStr = "0";
}
String resultMessage = "";
String url ="";
//在这里需要处理从当年的基金当中扣除该补贴金额
double oldExtFee = 0;
double oldSelfFee = 0;
if(Utils.isNotEmpty(recordId))
{
oldExtFee = eqptUseRecord.getExtFee().doubleValue();
oldSelfFee = eqptUseRecord.getSelfFee().doubleValue();
}
resultMessage = this.eqptBookManager.extFeeProcess(new Date(),Double.valueOf(selfFeeStr).doubleValue(),
Double.valueOf(extFeeStr).doubleValue(),oldSelfFee,oldExtFee);
if(Utils.isNotEmpty(resultMessage))
{
url = "admin.eqptBookInfoStatistics.do?method=edit&bookId="+bookId;
}
else
{
eqptUseRecord.setSelfFee(new Double(selfFeeStr));
eqptUseRecord.setExtFee(new Double(extFeeStr));
}
if(Utils.isEmpty(recordId))
{
eqptUseRecord.setEnterDate(new Date());
}
eqptUseRecord.setScLoginUserByEnterUser(scLoginUser);
eqptUseRecord.setEqptBook(eqptBook);
eqptBook.getEqptUseRecords().add(eqptUseRecord);
//接着修改预约记录的状态
if(!"bookWarn".equals(request.getParameter("operator"))&&!"stop".equals(request.getParameter("operator"))){
eqptBook.setCodeBookStep(eqptBookManager.get(CodeBookStep.class,step));
}
//utilDao.deleteRecord("eqpt_use_record", "book_id", eqptBook.getBookId());
if("bookWarn".equals(request.getParameter("operator"))){
eqptBook.getScLoginUserByLoginId().setWarnFlag(eqptBook.getScLoginUserByLoginId().getWarnFlag()+1);
eqptBook.getScLoginUserByLoginId().setWarnStatus("000");
eqptBook.setReleaseFlag("1");
eqptBook.setCodeBookStep(eqptBookManager.get(CodeBookStep.class,"5"));
}
if("stop".equals(request.getParameter("operator"))) {
eqptBook.setReleaseFlag("1");
eqptBook.setCodeBookStep(eqptBookManager.get(CodeBookStep.class,"6"));
}
if(Utils.isEmpty(resultMessage))
{
resultMessage = "用户使用记录操作成功！";
url = "admin.eqptBookInfo.do?method=list";
if(Utils.isEmpty(recordId))
{
this.eqptBookTaskManager.statisticsEqptBookTask(scLoginUser, eqptBook);
}
}
eqptBookManager.save(eqptBook);
request.setAttribute("resultMessage", resultMessage);
String taskFlag = request.getParameter("taskFlag");
if (Utils.isNotEmpty(taskFlag)) url = "show.eqptBookTask.do?taskFlg=0";
request.setAttribute("url", url);
return mapping.findForward("success");
}
/*
* 下载文件
*
*/
public ActionForward downFile(ActionMapping mapping, ActionForm form, HttpServletRequest request,
HttpServletResponse response) {
String error="";
String fileUrl=request.getParameter("fileUrl");
String fileName = request.getParameter("fileName");
try{
File file=new File(request.getRealPath("")+fileUrl);
if(file.exists()){//文件存在时
response.setContentType ("application/OCTET-STREAM;charset=GBK");
String downName=UC2GB.toUni(fileName);
response.setHeader ("Content-Disposition", "attachment;filename=\""+downName+"\"");
FileInputStream in = new FileInputStream(file);
OutputStream outstream=response.getOutputStream();
byte[] bytes=new byte[1024];
int len=0;
while((len=in.read(bytes))!=-1){
outstream.write(bytes,0,len);
}
in.close();
outstream.close();
}else{//文件不存在时
error="文件【"+fileName+"】不存在";
request.setAttribute("error",error);
return mapping.findForward("downFile");
}
}catch(IOException e){
error="文件下载出现错误,请重新下载！";
request.setAttribute("error",error);
return mapping.findForward("downFile");
}
return null;
}
/**
* 文件上传的处理.
*/
private String[] uploadFile(ActionForm form, HttpServletRequest request,
String inputName, String path) {
if (!(form instanceof DynaBean))
return null;
Object imgObj = ((DynaBean) form).get(inputName);
if (!(imgObj instanceof FormFile))
return null;
FormFile file = (FormFile) imgObj;
if (StringUtils.isBlank(file.getFileName()))
return null;
try {
InputStream in = file.getInputStream();
String filename=file.getFileName();//上传文件名
String filePath = request.getSession().getServletContext()
.getRealPath("/");
OutputStream out = new FileOutputStream(filePath + path
+ file.getFileName());
int bytesRead;
byte[] buffer = new byte[8192];
while ((bytesRead = in.read(buffer, 0, 8192)) != -1) {
out.write(buffer, 0, bytesRead);
}
out.close();
in.close();
//修改文件名
int index=filename.lastIndexOf(".");
String name=filename.substring(0,index);//原文件名
String suffix=filename.substring(index+1,filename.length());//后缀
//目标文件名
String destFileName = name+"_"+DateFormatUtils.format(new Date(), "yyyyMMdd")+
org.apache.commons.lang.StringUtils.leftPad(Math.round(Math.random() * 1000)+ "", 4, '0')+"."+suffix;
String sourceFileName=filePath+"/"+path+"/"+filename;
String destinationFileName = request.getSession()
.getServletContext().getRealPath(
"/" + path + "/" + destFileName);
File sourceFile=new File(sourceFileName);
File destFile=new File(destinationFileName);
sourceFile.renameTo(destFile);
String[] array={filename,destFileName};
return array;
} catch (Exception e) {
log.error("文件上传处理出错", e);
return null;
}
}
// 删除磁盘文件
public void deleteFile(EqptUseRecord eqptUseRecord,String[] delFileUrls, String path) {
if (delFileUrls != null && delFileUrls.length > 0)
{
for (int i = 0; i < delFileUrls.length; i++)
{
File file = new File(path + delFileUrls[i]);
if (file.exists())
file.delete();
}
if(Utils.isNotEmpty(eqptUseRecord.getReport())&&Utils.isNotEmpty(eqptUseRecord.getReporturl()))
{
String[] fileNames = eqptUseRecord.getReport().split(",");
String[] fileUrls = eqptUseRecord.getReporturl().split(",");
String report = "";
String reportUrl = "";
for(int i = 0;i<fileUrls.length;i++)
{
if(!this.hasFileUrl(fileUrls[i], delFileUrls))
{
report += fileNames[i]+",";
reportUrl += fileUrls[i]+",";
}
}
eqptUseRecord.setReport(report);
eqptUseRecord.setReporturl(reportUrl);
}
}
}
private boolean hasFileUrl(String fileUrl,String[] delFileUrls)
{
boolean result = false;
if(delFileUrls!=null)
{
for(String delFileUrl:delFileUrls)
{
if(delFileUrl.equals(fileUrl))
{
result = true;
break;
}
}
}
return result;
}
}
14 楼
spyker
2009-03-20
manyinjin 写道
JohnnyJian 写道
这还不是最简单的，试试：
Java代码 println new URL("http://manyinjin.iteye.com").text println new URL("http://manyinjin.iteye.com").text
呵呵，试了一下，真的很cool
像这个，
new File( 'd:\\tmp\\test.log' ).eachLine{ line ->
if(line =~ ".*127.0.0.1.*") println line;
}
真的很简单。
perl
python里面基本都是这样吧
为啥痴迷语法呢
13 楼
night_stalker
2009-03-20
Bernard 写道
就算是动态语言也应该有一套严格的语法。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
groovy保持java的样子，模仿动态语言语法，同时也包装了一些java hack……
虽说编译成静态，但是动态语法大量使用反射泛型和动态代理和动态装载，速度比正常java慢很多，与解释执行相比也体现不出编译的效率优势。
看看《java解惑》，java里令人抓狂的陷阱也不少。
日常说话聊天比动态语言灵活多了，也无所适从么？
12 楼
Bernard
2009-03-20
就算是动态语言也应该有一套严格的语法。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
就如前几楼说的URL获取内容一样。
过于灵活会让人觉得无所适从。
Php中有 fopen,file_get_contents,curl等可以用来获取远程内容。
但各有特点，适用于不同情况。
如果像Js那样偶尔再蹦出几个hack那就太令人抓狂了。
11 楼
xmpp
2009-03-20
看下面的代码：
class Module {
static def abc = {return "打印测试"}
static def hij = {person->return person.name}
}
class Person {String name;}
def d = new Person(name:"123");
d.metaClass.abc = {->
Module.abc()
}
d.metaClass.hij = {person->
Module.hij(person)
}
println d.abc()
println d.hij(d)
class Module {
static def abc = {return "打印测试"}
static def hij = {person->return person.name}
}
class Person {String name;}
def d = new Person(name:"123");
d.metaClass.abc = {->
Module.abc()
}
d.metaClass.hij = {person->
Module.hij(person)
}
println d.abc()
println d.hij(d)
10 楼
Dreamer
2009-03-20
Groovy比Python和Ruby更吸引我的地方全部来自于它的语法风格。
9 楼
manyinjin
2009-03-20
tinyyea 写道
概念很酷！groovy只是语法表面上动态而已，语法上充斥着魔法，最终还是要编译成java class文件，在一个JVM静态的容器中运行，本质上还是静态的。 groovy倒像是java语法动态化的一个极端。说groovy可以和java无缝结合到一起，真的，这太理想，当我在java里修改一个类的名字，我得到groovy里找到引用的地方一个个改掉，这真得很郁闷。动态语法给IDE支持造成困难，特别是重构方面，简便快捷的重构也意味着良好的维护，反之亦然，说来说去又说到动态语法不容易维护的通病。编程简单，维护困难。编程困难，维护简单。平衡一点，希望java变得再动态一点。
嗯，我看了一下它最终生成的字节码，该有什么还是有什么，有点类似cglib做的事情。Groovy用在特定的场合还是很有优势的，比如，写写测试脚本和用例什么的。但是如果真要用来做大的应用，确实会存在很多问题，比如，效率问题，维护问题等。
8 楼
manyinjin
2009-03-20
JohnnyJian 写道
这还不是最简单的，试试：
Java代码 println new URL("http://manyinjin.iteye.com").text println new URL("http://manyinjin.iteye.com").text
呵呵，试了一下，真的很cool
像这个，
new File( 'd:\\tmp\\test.log' ).eachLine{ line ->
if(line =~ ".*127.0.0.1.*") println line;
}
真的很简单。
7 楼
JohnnyJian
2009-03-18
tinyyea 写道
说groovy可以和java无缝结合到一起，真的，这太理想，当我在java里修改一个类的名字，我得到groovy里找到引用的地方一个个改掉，这真得很郁闷。
你用什么IDE？我用IDEA修改类名的时候是可以自动把groovy中的也改掉的。
6 楼
tinyyea
2009-03-18
概念很酷！
groovy只是语法表面上动态而已，语法上充斥着魔法，最终还是要编译成java class文件，在一个JVM静态的容器中运行，本质上还是静态的。
groovy倒像是java语法动态化的一个极端。
说groovy可以和java无缝结合到一起，真的，这太理想，当我在java里修改一个类的名字，我得到groovy里找到引用的地方一个个改掉，这真得很郁闷。
动态语法给IDE支持造成困难，特别是重构方面，简便快捷的重构也意味着良好的维护，反之亦然，说来说去又说到动态语法不容易维护的通病。
编程简单，维护困难。
编程困难，维护简单。
平衡一点，希望java变得再动态一点。
groovy只是语法表面上动态而已，语法上充斥着魔法，最终还是要编译成java class文件，在一个JVM静态的容器中运行，本质上还是静态的。
groovy倒像是java语法动态化的一个极端。
说groovy可以和java无缝结合到一起，真的，这太理想，当我在java里修改一个类的名字，我得到groovy里找到引用的地方一个个改掉，这真得很郁闷。
动态语法给IDE支持造成困难，特别是重构方面，简便快捷的重构也意味着良好的维护，反之亦然，说来说去又说到动态语法不容易维护的通病。
编程简单，维护困难。
编程困难，维护简单。
平衡一点，希望java变得再动态一点。
5 楼
刑天战士
2009-03-17
这个任何动态语言都可以的……
4 楼
JohnnyJian
2009-03-17
yipsilon 写道
要是能自动封装Getter/Setter就好了。例如你的例子：
println new URL("http://manyinjin.iteye.com").openConnection().inputStream.text;
可以的
3 楼
JohnnyJian
2009-03-17
第二段还可以写成：
class Person{
String name
String idCard
}
def p = new Person(name:"manyinjin", idCard:"my idcard #")
println p['name']
println p.name
2 楼
yipsilon
2009-03-17
要是能自动封装Getter/Setter就好了。例如你的例子：
println new URL("http://manyinjin.iteye.com").openConnection().inputStream.text;
1 楼
JohnnyJian
2009-03-17
这还不是最简单的，试试：
println new URL("http://manyinjin.iteye.com").text
发表评论
相关推荐
为了进一步学习，你可以通过阅读"第一讲 项目演示与搭建Groovy开发环境"的文档，或者查看"µÚÒ»½² ÏîÄ¿ÑÝʾÓë´î½¨Groovy¿ª·¢»·¾³"的资料。这些资源将详细解释如何从零开始构建一个Groovy...
apache-groovy-3.0.8.zip apache官网的groovy3.0.8版本，希望大家多多下载，apache-groovy-3.0.8.zip apache官网的groovy3.0.8版本，希望大家多多下载，apache-groovy-3.0.8.zip apache官网的groovy3.0.8版本，希望...
Groovy是一种基于Java平台的、动态的、强大的编程语言，它设计的目标是增强开发者的生产力。Groovy结合了Java的静态类型系统和Python、Ruby等动态语言的灵活性，使得开发者可以更加高效地编写代码。本篇文章将深入...
groovy安装包-win（第一部分）groovy安装包-win（第一部分）
##### 3.2 编写第一个Groovy脚本 ```groovy // hello.groovy println "Hello, Groovy!" ``` 1. **创建Groovy文件**：使用文本编辑器创建一个名为hello.groovy的文件，并输入以上代码。 2. **执行脚本**：打开...
Groovy是一种动态、开源的编程语言，它是Java平台上的一个JVM（Java Virtual Machine）语言。Groovy结合了Python、Ruby和Perl等脚本语言的简洁性和灵活性，并且完全兼容Java，可以无缝地与Java代码集成。在"groovy-...
Groovy 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。在编写新应用程序时，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有...
1. 引入Groovy库：在Java项目中添加Groovy的相关依赖，通常是`groovy-all`，确保Java能够访问Groovy运行时环境。 2. 创建GroovyClassLoader：使用这个类加载器可以动态加载和执行Groovy脚本。它继承自Java的...
闭包是Groovy的一个核心特性，它类似于函数指针，可以被用作参数传递或者作为返回值。闭包在Groovy中的定义形式通常为`{参数列表 -> 代码块}`。闭包的this指针在闭包内部指向创建它的上下文对象，而`@delegate`注解...
#### 一、Groovy简介与特性 Groovy是一种为Java虚拟机（JVM）设计的动态语言。它具备完全的对象导向性、可选的类型系统、操作符定制能力、简洁的数据类型声明、闭包（Closures）、范围表达（Ranges）、紧凑的属性...
Groovy SDK 4.0.3 是一个针对Groovy编程语言的软件开发工具包，它包含了Groovy语言的运行环境和开发所需的各种组件。Groovy是一种动态、灵活的面向对象编程语言，它与Java语法兼容，但提供了更简洁的语法和更强的...
1. **下载 GroovyEclipse.zip 文件**：访问 Groovy 的官方网站或 GitHub 仓库获取最新版本的 GroovyEclipse.zip 文件。确保选择与您的 Eclipse 版本兼容的插件版本。 2. **解压 GroovyEclipse.zip 文件**：将下载的...
Groovy是一种基于Java平台的动态脚本语言，它在设计时考虑了简洁性和生产力的提升。Groovy之所以受到青睐，主要是因为它比Java更加抽象和高效，允许开发者编写更少的代码来实现同样的功能。以下是对Groovy的一些核心...
闭包（closures）是Groovy中非常重要的一个概念，闭包是一种可以作为参数传递、可以从其被定义的作用域外调用的代码块。Groovy的闭包提供了非常强大的功能，比如高阶函数的能力，它们可以用来实现迭代、排序和其他...
Groovy是一种动态、开源的编程语言，它是Java平台上的一个重要的补充。Groovy结合了Python、Ruby和Smalltalk等语言的特性，同时保留了与Java的无缝集成能力，使得它在脚本编写、Web开发、自动化测试等领域有着广泛的...
1. **groovy-all.jar**：这是一个包含了Groovy库所有模块的集合，你可以通过引入这个单一的jar文件来快速地在项目中使用Groovy。 2. **bin**目录：包含了一系列可执行脚本，如`groovy`, `groovyc`, 和 `groovysh`，...
Groovy 是一种基于 Java 语言的脚本语言，运行在 JVM 中，语法与 Java 相似，但抛弃了 Java 的一些烦琐的语法规则，提供了更加简洁和灵活的编程体验。 Groovy 的特点 1. 简洁的语法：Groovy 语法简洁，减少了代码...