ChihPingM
ChihPingM

docx4j操作word常用方法

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;


import javax.xml.bind.JAXBElement;


import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.docx4j.TextUtils;
import org.docx4j.XmlUtils;
import org.docx4j.dml.wordprocessingDrawing.Inline;
import org.docx4j.model.properties.table.tr.TrHeight;
import org.docx4j.openpackaging.packages.OpcPackage;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
import org.docx4j.openpackaging.parts.relationships.Namespaces;
import org.docx4j.wml.BooleanDefaultTrue;
import org.docx4j.wml.Br;
import org.docx4j.wml.CTBackground;
import org.docx4j.wml.CTBorder;
import org.docx4j.wml.CTEm;
import org.docx4j.wml.CTHeight;
import org.docx4j.wml.CTLineNumber;
import org.docx4j.wml.CTShd;
import org.docx4j.wml.CTSignedHpsMeasure;
import org.docx4j.wml.CTSignedTwipsMeasure;
import org.docx4j.wml.CTTblCellMar;
import org.docx4j.wml.CTTextScale;
import org.docx4j.wml.CTVerticalAlignRun;
import org.docx4j.wml.CTVerticalJc;
import org.docx4j.wml.Color;
import org.docx4j.wml.ContentAccessor;
import org.docx4j.wml.Drawing;
import org.docx4j.wml.Highlight;
import org.docx4j.wml.HpsMeasure;
import org.docx4j.wml.Jc;
import org.docx4j.wml.JcEnumeration;
import org.docx4j.wml.ObjectFactory;
import org.docx4j.wml.P;
import org.docx4j.wml.P.Hyperlink;
import org.docx4j.wml.PPr;
import org.docx4j.wml.PPrBase.Ind;
import org.docx4j.wml.PPrBase.PBdr;
import org.docx4j.wml.PPrBase.Spacing;
import org.docx4j.wml.ParaRPr;
import org.docx4j.wml.R;
import org.docx4j.wml.RFonts;
import org.docx4j.wml.RPr;
import org.docx4j.wml.STBorder;
import org.docx4j.wml.STBrType;
import org.docx4j.wml.STEm;
import org.docx4j.wml.STLineNumberRestart;
import org.docx4j.wml.STLineSpacingRule;
import org.docx4j.wml.STPageOrientation;
import org.docx4j.wml.STShd;
import org.docx4j.wml.STVerticalAlignRun;
import org.docx4j.wml.STVerticalJc;
import org.docx4j.wml.SectPr;
import org.docx4j.wml.SectPr.PgBorders;
import org.docx4j.wml.SectPr.PgMar;
import org.docx4j.wml.SectPr.PgSz;
import org.docx4j.wml.SectPr.Type;
import org.docx4j.wml.Tbl;
import org.docx4j.wml.TblBorders;
import org.docx4j.wml.TblGrid;
import org.docx4j.wml.TblGridCol;
import org.docx4j.wml.TblPr;
import org.docx4j.wml.TblWidth;
import org.docx4j.wml.Tc;
import org.docx4j.wml.TcPr;
import org.docx4j.wml.TcPrInner.GridSpan;
import org.docx4j.wml.TcPrInner.HMerge;
import org.docx4j.wml.TcPrInner.VMerge;
import org.docx4j.wml.Text;
import org.docx4j.wml.TextDirection;
import org.docx4j.wml.Tr;
import org.docx4j.wml.TrPr;
import org.docx4j.wml.U;
import org.docx4j.wml.UnderlineEnumeration;


//代码基于docx4j-3.2.0
public class Docx4j_工具类_S3_Test {


/*------------------------------------other---------------------------------------------------  */
/**
* @Description:新增超链接
*/
public void createHyperlink(WordprocessingMLPackage wordMLPackage,
MainDocumentPart mainPart, ObjectFactory factory, P paragraph,
String url, String value, String cnFontName, String enFontName,
String fontSize) throws Exception {
if (StringUtils.isBlank(enFontName)) {
enFontName = "Times New Roman";
}
if (StringUtils.isBlank(cnFontName)) {
cnFontName = "微软雅黑";
}
if (StringUtils.isBlank(fontSize)) {
fontSize = "22";
}
org.docx4j.relationships.ObjectFactory reFactory = new org.docx4j.relationships.ObjectFactory();
org.docx4j.relationships.Relationship rel = reFactory
.createRelationship();
rel.setType(Namespaces.HYPERLINK);
rel.setTarget(url);
rel.setTargetMode("External");
mainPart.getRelationshipsPart().addRelationship(rel);
StringBuffer sb = new StringBuffer();
// addRelationship sets the rel's @Id
sb.append("");
sb.append("");
sb.append("");
sb.append("");
sb.append(value);
sb.append("");


Hyperlink link = (Hyperlink) XmlUtils.unmarshalString(sb.toString());
paragraph.getContent().add(link);
}


public String getElementContent(Object obj) throws Exception {
StringWriter stringWriter = new StringWriter();
TextUtils.extractText(obj, stringWriter);
return stringWriter.toString();
}


/**
* @Description:得到指定类型的元素
*/
public static List getAllElementFromObject(Object obj,
Class toSearch) {
List result = new ArrayList();
if (obj instanceof JAXBElement)
obj = ((JAXBElement) obj).getValue();
if (obj.getClass().equals(toSearch))
result.add(obj);
else if (obj instanceof ContentAccessor) {
List children = ((ContentAccessor) obj).getContent();
for (Object child : children) {
result.addAll(getAllElementFromObject(child, toSearch));
}
}
return result;
}


/**
* @Description:保存WordprocessingMLPackage
*/
public void saveWordPackage(WordprocessingMLPackage wordPackage, File file)
throws Exception {
wordPackage.save(file);
}


/**
* @Description:新建WordprocessingMLPackage
*/
public WordprocessingMLPackage createWordprocessingMLPackage()
throws Exception {
return WordprocessingMLPackage.createPackage();
}


/**
* @Description:加载带密码WordprocessingMLPackage
*/
public WordprocessingMLPackage loadWordprocessingMLPackageWithPwd(
String filePath, String password) throws Exception {
OpcPackage opcPackage = WordprocessingMLPackage.load(new java.io.File(
filePath), password);
WordprocessingMLPackage wordMLPackage = (WordprocessingMLPackage) opcPackage;
return wordMLPackage;
}


/**
* @Description:加载WordprocessingMLPackage
*/
public WordprocessingMLPackage loadWordprocessingMLPackage(String filePath)
throws Exception {
WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage
.load(new java.io.File(filePath));
return wordMLPackage;
}


/*------------------------------------Word 表格相关---------------------------------------------------  */
/**
* @Description: 跨列合并
*/
public void mergeCellsHorizontalByGridSpan(Tbl tbl, int row, int fromCell,
int toCell) {
if (row < 0 || fromCell < 0 || toCell < 0) {
return;
}
List trList = getTblAllTr(tbl);
if (row > trList.size()) {
return;
}
Tr tr = trList.get(row);
List tcList = getTrAllCell(tr);
for (int cellIndex = Math.min(tcList.size() - 1, toCell); cellIndex >= fromCell; cellIndex--) {
Tc tc = tcList.get(cellIndex);
TcPr tcPr = getTcPr(tc);
if (cellIndex == fromCell) {
GridSpan gridSpan = tcPr.getGridSpan();
if (gridSpan == null) {
gridSpan = new GridSpan();
tcPr.setGridSpan(gridSpan);
}
gridSpan.setVal(BigInteger.valueOf(Math.min(tcList.size() - 1,
toCell) - fromCell + 1));
} else {
tr.getContent().remove(cellIndex);
}
}
}


/**
* @Description: 跨列合并
*/
public void mergeCellsHorizontal(Tbl tbl, int row, int fromCell, int toCell) {
if (row < 0 || fromCell < 0 || toCell < 0) {
return;
}
List trList = getTblAllTr(tbl);
if (row > trList.size()) {
return;
}
Tr tr = trList.get(row);
List tcList = getTrAllCell(tr);
for (int cellIndex = fromCell, len = Math
.min(tcList.size() - 1, toCell); cellIndex <= len; cellIndex++) {
Tc tc = tcList.get(cellIndex);
TcPr tcPr = getTcPr(tc);
HMerge hMerge = tcPr.getHMerge();
if (hMerge == null) {
hMerge = new HMerge();
tcPr.setHMerge(hMerge);
}
if (cellIndex == fromCell) {
hMerge.setVal("restart");
} else {
hMerge.setVal("continue");
}
}
}


/**
* @Description: 跨行合并
*/
public void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {
if (col < 0 || fromRow < 0 || toRow < 0) {
return;
}
for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
Tc tc = getTc(tbl, rowIndex, col);
if (tc == null) {
break;
}
TcPr tcPr = getTcPr(tc);
VMerge vMerge = tcPr.getVMerge();
if (vMerge == null) {
vMerge = new VMerge();
tcPr.setVMerge(vMerge);
}
if (rowIndex == fromRow) {
vMerge.setVal("restart");
} else {
vMerge.setVal("continue");
}
}
}


/**
* @Description:得到指定位置的单元格
*/
public Tc getTc(Tbl tbl, int row, int cell) {
if (row < 0 || cell < 0) {
return null;
}
List trList = getTblAllTr(tbl);
if (row >= trList.size()) {
return null;
}
List tcList = getTrAllCell(trList.get(row));
if (cell >= tcList.size()) {
return null;
}
return tcList.get(cell);
}


/**
* @Description:得到所有表格
*/
public List getAllTbl(WordprocessingMLPackage wordMLPackage) {
MainDocumentPart mainDocPart = wordMLPackage.getMainDocumentPart();
List objList = getAllElementFromObject(mainDocPart, Tbl.class);
if (objList == null) {
return null;
}
List tblList = new ArrayList();
for (Object obj : objList) {
if (obj instanceof Tbl) {
Tbl tbl = (Tbl) obj;
tblList.add(tbl);
}
}
return tblList;
}


/**
* @Description:删除指定位置的表格,删除后表格数量减一
*/
public boolean removeTableByIndex(WordprocessingMLPackage wordMLPackage,
int index) throws Exception {
boolean flag = false;
if (index < 0) {
return flag;
}
List objList = wordMLPackage.getMainDocumentPart().getContent();
if (objList == null) {
return flag;
}
int k = -1;
for (int i = 0, len = objList.size(); i < len; i++) {
Object obj = XmlUtils.unwrap(objList.get(i));
if (obj instanceof Tbl) {
k++;
if (k == index) {
wordMLPackage.getMainDocumentPart().getContent().remove(i);
flag = true;
break;
}
}
}
return flag;
}


/**
* @Description: 获取单元格内容,无分割符
*/
public String getTblContentStr(Tbl tbl) throws Exception {
return getElementContent(tbl);
}




/**
* @Description: 获取表格内容
*/
public List getTblContentList(Tbl tbl) throws Exception {
List resultList = new ArrayList();
List trList = getTblAllTr(tbl);
for (Tr tr : trList) {
StringBuffer sb = new StringBuffer();
List tcList = getTrAllCell(tr);
for (Tc tc : tcList) {
sb.append(getElementContent(tc) + ",");
}
resultList.add(sb.toString());
}
return resultList;
}


public TblPr getTblPr(Tbl tbl) {
TblPr tblPr = tbl.getTblPr();
if (tblPr == null) {
tblPr = new TblPr();
tbl.setTblPr(tblPr);
}
return tblPr;
}


/**
* @Description: 设置表格总宽度
*/
public void setTableWidth(Tbl tbl, String width) {
if (StringUtils.isNotBlank(width)) {
TblPr tblPr = getTblPr(tbl);
TblWidth tblW = tblPr.getTblW();
if (tblW == null) {
tblW = new TblWidth();
tblPr.setTblW(tblW);
}
tblW.setW(new BigInteger(width));
tblW.setType("dxa");
}
}


/**
* @Description:创建表格(默认水平居中,垂直居中)
*/
public Tbl createTable(WordprocessingMLPackage wordPackage, int rowNum,
int colsNum) throws Exception {
colsNum = Math.max(1, colsNum);
rowNum = Math.max(1, rowNum);
int widthTwips = getWritableWidth(wordPackage);
int colWidth = widthTwips / colsNum;
int[] widthArr = new int[colsNum];
for (int i = 0; i < colsNum; i++) {
widthArr[i] = colWidth;
}
return createTable(rowNum, colsNum, widthArr);
}


/**
* @Description:创建表格(默认水平居中,垂直居中)
*/
public Tbl createTable(int rowNum, int colsNum, int[] widthArr)
throws Exception {
colsNum = Math.max(1, Math.min(colsNum, widthArr.length));
rowNum = Math.max(1, rowNum);
Tbl tbl = new Tbl();
StringBuffer tblSb = new StringBuffer();
tblSb.append("");
tblSb.append("");
tblSb.append("");
// 上边框
tblSb.append("");
tblSb.append("");
// 左边框
tblSb.append("");
// 下边框
tblSb.append("");
// 右边框
tblSb.append("");
tblSb.append("");
tblSb.append("");
tblSb.append("");
tblSb.append("");
TblPr tblPr = null;
tblPr = (TblPr) XmlUtils.unmarshalString(tblSb.toString());
Jc jc = new Jc();
// 单元格居中对齐
jc.setVal(JcEnumeration.CENTER);
tblPr.setJc(jc);


tbl.setTblPr(tblPr);


// 设定各单元格宽度
TblGrid tblGrid = new TblGrid();
tbl.setTblGrid(tblGrid);
for (int i = 0; i < colsNum; i++) {
TblGridCol gridCol = new TblGridCol();
gridCol.setW(BigInteger.valueOf(widthArr[i]));
tblGrid.getGridCol().add(gridCol);
}
// 新增行
for (int j = 0; j < rowNum; j++) {
Tr tr = new Tr();
tbl.getContent().add(tr);
// 列
for (int i = 0; i < colsNum; i++) {
Tc tc = new Tc();
tr.getContent().add(tc);


TcPr tcPr = new TcPr();
TblWidth cellWidth = new TblWidth();
cellWidth.setType("dxa");
cellWidth.setW(BigInteger.valueOf(widthArr[i]));
tcPr.setTcW(cellWidth);
tc.setTcPr(tcPr);


// 垂直居中
setTcVAlign(tc, STVerticalJc.CENTER);
P p = new P();
PPr pPr = new PPr();
pPr.setJc(jc);
p.setPPr(pPr);
R run = new R();
p.getContent().add(run);
tc.getContent().add(p);
}
}
return tbl;
}


/**
* @Description:表格增加边框 可以设置上下左右四个边框样式以及横竖水平线样式
*/
public void setTblBorders(TblPr tblPr, CTBorder topBorder,
CTBorder rightBorder, CTBorder bottomBorder, CTBorder leftBorder,
CTBorder hBorder, CTBorder vBorder) {
TblBorders borders = tblPr.getTblBorders();
if (borders == null) {
borders = new TblBorders();
tblPr.setTblBorders(borders);
}
if (topBorder != null) {
borders.setTop(topBorder);
}
if (rightBorder != null) {
borders.setRight(rightBorder);
}
if (bottomBorder != null) {
borders.setBottom(bottomBorder);
}
if (leftBorder != null) {
borders.setLeft(leftBorder);
}
if (hBorder != null) {
borders.setInsideH(hBorder);
}
if (vBorder != null) {
borders.setInsideV(vBorder);
}
}


/**
* @Description: 设置表格水平对齐方式(仅对表格起作用,单元格不一定水平对齐)
*/
public void setTblJcAlign(Tbl tbl, JcEnumeration jcType) {
if (jcType != null) {
TblPr tblPr = getTblPr(tbl);
Jc jc = tblPr.getJc();
if (jc == null) {
jc = new Jc();
tblPr.setJc(jc);
}
jc.setVal(jcType);
}
}


/**
* @Description: 设置表格水平对齐方式(包括单元格),只对该方法前面产生的单元格起作用
*/
public void setTblAllJcAlign(Tbl tbl, JcEnumeration jcType) {
if (jcType != null) {
setTblJcAlign(tbl, jcType);
List trList = getTblAllTr(tbl);
for (Tr tr : trList) {
List tcList = getTrAllCell(tr);
for (Tc tc : tcList) {
setTcJcAlign(tc, jcType);
}
}
}
}


/**
* @Description: 设置表格垂直对齐方式(包括单元格),只对该方法前面产生的单元格起作用
*/
public void setTblAllVAlign(Tbl tbl, STVerticalJc vAlignType) {
if (vAlignType != null) {
List trList = getTblAllTr(tbl);
for (Tr tr : trList) {
List tcList = getTrAllCell(tr);
for (Tc tc : tcList) {
setTcVAlign(tc, vAlignType);
}
}
}
}


/**
* @Description: 设置单元格Margin
*/
public void setTableCellMargin(Tbl tbl, String top, String right,
String bottom, String left) {
TblPr tblPr = getTblPr(tbl);
CTTblCellMar cellMar = tblPr.getTblCellMar();
if (cellMar == null) {
cellMar = new CTTblCellMar();
tblPr.setTblCellMar(cellMar);
}
if (StringUtils.isNotBlank(top)) {
TblWidth topW = new TblWidth();
topW.setW(new BigInteger(top));
topW.setType("dxa");
cellMar.setTop(topW);
}
if (StringUtils.isNotBlank(right)) {
TblWidth rightW = new TblWidth();
rightW.setW(new BigInteger(right));
rightW.setType("dxa");
cellMar.setRight(rightW);
}
if (StringUtils.isNotBlank(bottom)) {
TblWidth btW = new TblWidth();
btW.setW(new BigInteger(bottom));
btW.setType("dxa");
cellMar.setBottom(btW);
}
if (StringUtils.isNotBlank(left)) {
TblWidth leftW = new TblWidth();
leftW.setW(new BigInteger(left));
leftW.setType("dxa");
cellMar.setLeft(leftW);
}
}


/**
* @Description: 得到表格所有的行
*/
public List getTblAllTr(Tbl tbl) {
List objList = getAllElementFromObject(tbl, Tr.class);
List trList = new ArrayList();
if (objList == null) {
return trList;
}
for (Object obj : objList) {
if (obj instanceof Tr) {
Tr tr = (Tr) obj;
trList.add(tr);
}
}
return trList;


}


/**
* @Description:设置tr高度
*/
public void setTrHeight(Tr tr, String heigth) {
TrPr trPr = getTrPr(tr);
CTHeight ctHeight = new CTHeight();
ctHeight.setVal(new BigInteger(heigth));
TrHeight trHeight = new TrHeight(ctHeight);
trHeight.set(trPr);
}


/**
* @Description: 在表格指定位置新增一行,默认居中
*/
public void addTrByIndex(Tbl tbl, int index) {
addTrByIndex(tbl, index, STVerticalJc.CENTER, JcEnumeration.CENTER);
}


/**
* @Description: 在表格指定位置新增一行(默认按表格定义的列数添加)
*/
public void addTrByIndex(Tbl tbl, int index, STVerticalJc vAlign,
JcEnumeration hAlign) {
TblGrid tblGrid = tbl.getTblGrid();
Tr tr = new Tr();
if (tblGrid != null) {
List gridList = tblGrid.getGridCol();
for (TblGridCol tblGridCol : gridList) {
Tc tc = new Tc();
setTcWidth(tc, tblGridCol.getW().toString());
if (vAlign != null) {
// 垂直居中
setTcVAlign(tc, vAlign);
}
P p = new P();
if (hAlign != null) {
PPr pPr = new PPr();
Jc jc = new Jc();
// 单元格居中对齐
jc.setVal(hAlign);
pPr.setJc(jc);
p.setPPr(pPr);
}
R run = new R();
p.getContent().add(run);
tc.getContent().add(p);
tr.getContent().add(tc);
}
} else {
// 大部分情况都不会走到这一步
Tr firstTr = getTblAllTr(tbl).get(0);
int cellSize = getTcCellSizeWithMergeNum(firstTr);
for (int i = 0; i < cellSize; i++) {
Tc tc = new Tc();
if (vAlign != null) {
// 垂直居中
setTcVAlign(tc, vAlign);
}
P p = new P();
if (hAlign != null) {
PPr pPr = new PPr();
Jc jc = new Jc();
// 单元格居中对齐
jc.setVal(hAlign);
pPr.setJc(jc);
p.setPPr(pPr);
}
R run = new R();
p.getContent().add(run);
tc.getContent().add(p);
tr.getContent().add(tc);
}
}
if (index >= 0&&index tcList = getTrAllCell(tr);
if (tcList == null || tcList.size() == 0) {
return cellSize;
}
cellSize = tcList.size();
for (Tc tc : tcList) {
TcPr tcPr = getTcPr(tc);
GridSpan gridSpan = tcPr.getGridSpan();
if (gridSpan != null) {
cellSize += gridSpan.getVal().intValue() - 1;
}
}
return cellSize;
}


/**
* @Description: 删除指定行 删除后行数减一
*/
public boolean removeTrByIndex(Tbl tbl, int index) {
boolean flag = false;
if (index < 0) {
return flag;
}
List objList = tbl.getContent();
if (objList == null) {
return flag;
}
int k = -1;
for (int i = 0, len = objList.size(); i < len; i++) {
Object obj = XmlUtils.unwrap(objList.get(i));
if (obj instanceof Tr) {
k++;
if (k == index) {
tbl.getContent().remove(i);
flag = true;
break;
}
}
}
return flag;
}


public TrPr getTrPr(Tr tr) {
TrPr trPr = tr.getTrPr();
if (trPr == null) {
trPr = new TrPr();
tr.setTrPr(trPr);
}
return trPr;
}


/**
* @Description:隐藏行(只对表格中间的部分起作用,不包括首尾行)
*/
public void setTrHidden(Tr tr, boolean hidden) {
List tcList = getTrAllCell(tr);
for (Tc tc : tcList) {
setTcHidden(tc, hidden);
}
}


/**
* @Description: 设置单元格宽度
*/
public void setTcWidth(Tc tc, String width) {
if (StringUtils.isNotBlank(width)) {
TcPr tcPr = getTcPr(tc);
TblWidth tcW = tcPr.getTcW();
if (tcW == null) {
tcW = new TblWidth();
tcPr.setTcW(tcW);
}
tcW.setW(new BigInteger(width));
tcW.setType("dxa");
}
}


/**
* @Description: 隐藏单元格内容
*/
public void setTcHidden(Tc tc, boolean hidden) {
List
 pList = getTcAllP(tc);
for (P p : pList) {
PPr ppr = getPPr(p);
List objRList = getAllElementFromObject(p, R.class);
if (objRList == null) {
continue;
}
for (Object objR : objRList) {
if (objR instanceof R) {
R r = (R) objR;
RPr rpr = getRPr(r);
setRPrVanishStyle(rpr, hidden);
}
}
setParaVanish(ppr, hidden);
}
}


public List
 getTcAllP(Tc tc) {
List objList = getAllElementFromObject(tc, P.class);
List
 pList = new ArrayList
();
if (objList == null) {
return pList;
}
for (Object obj : objList) {
if (obj instanceof P) {
P p = (P) obj;
pList.add(p);
}
}
return pList;
}


public TcPr getTcPr(Tc tc) {
TcPr tcPr = tc.getTcPr();
if (tcPr == null) {
tcPr = new TcPr();
tc.setTcPr(tcPr);
}
return tcPr;
}


/**
* @Description: 设置单元格垂直对齐方式
*/
public void setTcVAlign(Tc tc, STVerticalJc vAlignType) {
if (vAlignType != null) {
TcPr tcPr = getTcPr(tc);
CTVerticalJc vAlign = new CTVerticalJc();
vAlign.setVal(vAlignType);
tcPr.setVAlign(vAlign);
}
}


/**
* @Description: 设置单元格水平对齐方式
*/
public void setTcJcAlign(Tc tc, JcEnumeration jcType) {
if (jcType != null) {
List
 pList = getTcAllP(tc);
for (P p : pList) {
setParaJcAlign(p, jcType);
}
}
}


public RPr getRPr(R r) {
RPr rpr = r.getRPr();
if (rpr == null) {
rpr = new RPr();
r.setRPr(rpr);
}
return rpr;
}


/**
* @Description: 获取所有的单元格
*/
public List getTrAllCell(Tr tr) {
List objList = getAllElementFromObject(tr, Tc.class);
List tcList = new ArrayList();
if (objList == null) {
return tcList;
}
for (Object tcObj : objList) {
if (tcObj instanceof Tc) {
Tc objTc = (Tc) tcObj;
tcList.add(objTc);
}
}
return tcList;
}


/**
* @Description: 获取单元格内容
*/
public String getTcContent(Tc tc) throws Exception {
return getElementContent(tc);
}


/**
* @Description:设置单元格内容,content为null则清除单元格内容
*/
public void setTcContent(Tc tc, RPr rpr, String content) {
List pList = tc.getContent();
P p = null;
if (pList != null && pList.size() > 0) {
if (pList.get(0) instanceof P) {
p = (P) pList.get(0);
}
} else {
p = new P();
tc.getContent().add(p);
}
R run = null;
List rList = p.getContent();
if (rList != null && rList.size() > 0) {
for (int i = 0, len = rList.size(); i < len; i++) {
// 清除内容(所有的r
p.getContent().remove(0);
}
}
run = new R();
p.getContent().add(run);
if (content != null) {
String[] contentArr = content.split("\n");
Text text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[0]);
run.setRPr(rpr);
run.getContent().add(text);


for (int i = 1, len = contentArr.length; i < len; i++) {
Br br = new Br();
run.getContent().add(br);// 换行
text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[i]);
run.setRPr(rpr);
run.getContent().add(text);
}
}
}


/**
* @Description:设置单元格内容,content为null则清除单元格内容
*/
public void removeTcContent(Tc tc) {
List pList = tc.getContent();
P p = null;
if (pList != null && pList.size() > 0) {
if (pList.get(0) instanceof P) {
p = (P) pList.get(0);
}
} else {
return;
}
List rList = p.getContent();
if (rList != null && rList.size() > 0) {
for (int i = 0, len = rList.size(); i < len; i++) {
// 清除内容(所有的r
p.getContent().remove(0);
}
}
}


/**
* @Description:删除指定位置的表格
* @deprecated
*/
public void deleteTableByIndex2(WordprocessingMLPackage wordMLPackage,
int index) throws Exception {
if (index < 0) {
return;
}
final String xpath = "(//w:tbl)[" + index + "]";
final List jaxbNodes = wordMLPackage.getMainDocumentPart()
.getJAXBNodesViaXPath(xpath, true);
if (jaxbNodes != null && jaxbNodes.size() > 0) {
wordMLPackage.getMainDocumentPart().getContent()
.remove(jaxbNodes.get(0));
}
}


/**
* @Description:获取NodeList
* @deprecated
*/
public List getObjectByXpath(WordprocessingMLPackage wordMLPackage,
String xpath) throws Exception {
final List jaxbNodes = wordMLPackage.getMainDocumentPart()
.getJAXBNodesViaXPath(xpath, true);
return jaxbNodes;
}


/*------------------------------------Word 段落相关---------------------------------------------------  */
/**
* @Description: 只删除单独的段落，不包括表格内或其他内的段落
*/
public boolean removeParaByIndex(WordprocessingMLPackage wordMLPackage,
int index) {
boolean flag = false;
if (index < 0) {
return flag;
}
List objList = wordMLPackage.getMainDocumentPart().getContent();
if (objList == null) {
return flag;
}
int k = -1;
for (int i = 0, len = objList.size(); i < len; i++) {
if (objList.get(i) instanceof P) {
k++;
if (k == index) {
wordMLPackage.getMainDocumentPart().getContent().remove(i);
flag = true;
break;
}
}
}
return flag;
}


/**
* @Description: 设置段落水平对齐方式
*/
public void setParaJcAlign(P paragraph, JcEnumeration hAlign) {
if (hAlign != null) {
PPr pprop = paragraph.getPPr();
if (pprop == null) {
pprop = new PPr();
paragraph.setPPr(pprop);
}
Jc align = new Jc();
align.setVal(hAlign);
pprop.setJc(align);
}
}


/**
* @Description: 设置段落内容
*/
public void setParaRContent(P p, RPr runProperties, String content) {
R run = null;
List rList = p.getContent();
if (rList != null && rList.size() > 0) {
for (int i = 0, len = rList.size(); i < len; i++) {
// 清除内容(所有的r
p.getContent().remove(0);
}
}
run = new R();
p.getContent().add(run);
if (content != null) {
String[] contentArr = content.split("\n");
Text text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[0]);
run.setRPr(runProperties);
run.getContent().add(text);


for (int i = 1, len = contentArr.length; i < len; i++) {
Br br = new Br();
run.getContent().add(br);// 换行
text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[i]);
run.setRPr(runProperties);
run.getContent().add(text);
}
}
}


/**
* @Description: 添加段落内容
*/
public void appendParaRContent(P p, RPr runProperties, String content) {
if (content != null) {
R run = new R();
p.getContent().add(run);
String[] contentArr = content.split("\n");
Text text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[0]);
run.setRPr(runProperties);
run.getContent().add(text);


for (int i = 1, len = contentArr.length; i < len; i++) {
Br br = new Br();
run.getContent().add(br);// 换行
text = new Text();
text.setSpace("preserve");
text.setValue(contentArr[i]);
run.setRPr(runProperties);
run.getContent().add(text);
}
}
}


/**
* @Description: 添加图片到段落
*/
public void addImageToPara(WordprocessingMLPackage wordMLPackage,
ObjectFactory factory, P paragraph, String filePath,
String content, RPr rpr, String altText, int id1, int id2)
throws Exception {
R run = factory.createR();
if (content != null) {
Text text = factory.createText();
text.setValue(content);
text.setSpace("preserve");
run.setRPr(rpr);
run.getContent().add(text);
}


InputStream is = new FileInputStream(filePath);
byte[] bytes = IOUtils.toByteArray(is);
BinaryPartAbstractImage imagePart = BinaryPartAbstractImage
.createImagePart(wordMLPackage, bytes);
Inline inline = imagePart.createImageInline(filePath, altText, id1,
id2, false);
Drawing drawing = factory.createDrawing();
drawing.getAnchorOrInline().add(inline);
run.getContent().add(drawing);
paragraph.getContent().add(run);
}


/**
* @Description: 段落添加Br 页面Break(分页符)
*/
public void addPageBreak(P para, STBrType sTBrType) {
Br breakObj = new Br();
breakObj.setType(sTBrType);
para.getContent().add(breakObj);
}


/**
* @Description: 设置段落是否禁止行号(禁止用于当前行号)
*/
public void setParagraphSuppressLineNum(P p) {
PPr ppr = getPPr(p);
BooleanDefaultTrue line = ppr.getSuppressLineNumbers();
if (line == null) {
line = new BooleanDefaultTrue();
}
line.setVal(true);
ppr.setSuppressLineNumbers(line);
}


/**
* @Description: 设置段落底纹(对整段文字起作用)
*/
public void setParagraphShdStyle(P p, STShd shdType, String shdColor) {
PPr ppr = getPPr(p);
CTShd ctShd = ppr.getShd();
if (ctShd == null) {
ctShd = new CTShd();
}
if (StringUtils.isNotBlank(shdColor)) {
ctShd.setColor(shdColor);
}
if (shdType != null) {
ctShd.setVal(shdType);
}
ppr.setShd(ctShd);
}


/**
* @param isSpace
*            是否设置段前段后值
* @param before
*            段前磅数
* @param after
*            段后磅数
* @param beforeLines
*            段前行数
* @param afterLines
*            段后行数
* @param isLine
*            是否设置行距
* @param lineValue
*            行距值
* @param sTLineSpacingRule
*            自动auto 固定exact 最小 atLeast 1磅=20 1行=100 单倍行距=240
*/
public void setParagraphSpacing(P p, boolean isSpace, String before,
String after, String beforeLines, String afterLines,
boolean isLine, String lineValue,
STLineSpacingRule sTLineSpacingRule) {
PPr pPr = getPPr(p);
Spacing spacing = pPr.getSpacing();
if (spacing == null) {
spacing = new Spacing();
pPr.setSpacing(spacing);
}
if (isSpace) {
if (StringUtils.isNotBlank(before)) {
// 段前磅数
spacing.setBefore(new BigInteger(before));
}
if (StringUtils.isNotBlank(after)) {
// 段后磅数
spacing.setAfter(new BigInteger(after));
}
if (StringUtils.isNotBlank(beforeLines)) {
// 段前行数
spacing.setBeforeLines(new BigInteger(beforeLines));
}
if (StringUtils.isNotBlank(afterLines)) {
// 段后行数
spacing.setAfterLines(new BigInteger(afterLines));
}
}
if (isLine) {
if (StringUtils.isNotBlank(lineValue)) {
spacing.setLine(new BigInteger(lineValue));
}
if (sTLineSpacingRule != null) {
spacing.setLineRule(sTLineSpacingRule);
}
}
}


/**
* @Description: 设置段落缩进信息 1厘米≈567
*/
public void setParagraphIndInfo(P p, String firstLine,
String firstLineChar, String hanging, String hangingChar,
String right, String rigthChar, String left, String leftChar) {
PPr ppr = getPPr(p);
Ind ind = ppr.getInd();
if (ind == null) {
ind = new Ind();
ppr.setInd(ind);
}
if (StringUtils.isNotBlank(firstLine)) {
ind.setFirstLine(new BigInteger(firstLine));
}
if (StringUtils.isNotBlank(firstLineChar)) {
ind.setFirstLineChars(new BigInteger(firstLineChar));
}
if (StringUtils.isNotBlank(hanging)) {
ind.setHanging(new BigInteger(hanging));
}
if (StringUtils.isNotBlank(hangingChar)) {
ind.setHangingChars(new BigInteger(hangingChar));
}
if (StringUtils.isNotBlank(left)) {
ind.setLeft(new BigInteger(left));
}
if (StringUtils.isNotBlank(leftChar)) {
ind.setLeftChars(new BigInteger(leftChar));
}
if (StringUtils.isNotBlank(right)) {
ind.setRight(new BigInteger(right));
}
if (StringUtils.isNotBlank(rigthChar)) {
ind.setRightChars(new BigInteger(rigthChar));
}
}


public PPr getPPr(P p) {
PPr ppr = p.getPPr();
if (ppr == null) {
ppr = new PPr();
p.setPPr(ppr);
}
return ppr;
}


public ParaRPr getParaRPr(PPr ppr) {
ParaRPr parRpr = ppr.getRPr();
if (parRpr == null) {
parRpr = new ParaRPr();
ppr.setRPr(parRpr);
}
return parRpr;


}


public void setParaVanish(PPr ppr, boolean isVanish) {
ParaRPr parRpr = getParaRPr(ppr);
BooleanDefaultTrue vanish = parRpr.getVanish();
if (vanish != null) {
vanish.setVal(isVanish);
} else {
vanish = new BooleanDefaultTrue();
parRpr.setVanish(vanish);
vanish.setVal(isVanish);
}
}


/**
* @Description: 设置段落边框样式
*/
public void setParagraghBorders(P p, CTBorder topBorder,
CTBorder bottomBorder, CTBorder leftBorder, CTBorder rightBorder) {
PPr ppr = getPPr(p);
PBdr pBdr = new PBdr();
if (topBorder != null) {
pBdr.setTop(topBorder);
}
if (bottomBorder != null) {
pBdr.setBottom(bottomBorder);
}
if (leftBorder != null) {
pBdr.setLeft(leftBorder);
}
if (rightBorder != null) {
pBdr.setRight(rightBorder);
}
ppr.setPBdr(pBdr);
}


/**
* @Description: 设置字体信息
*/
public void setFontStyle(RPr runProperties, String cnFontFamily,
String enFontFamily, String fontSize, String color) {
setFontFamily(runProperties, cnFontFamily, enFontFamily);
setFontSize(runProperties, fontSize);
setFontColor(runProperties, color);
}


/**
* @Description: 设置字体大小
*/
public void setFontSize(RPr runProperties, String fontSize) {
if (StringUtils.isNotBlank(fontSize)) {
HpsMeasure size = new HpsMeasure();
size.setVal(new BigInteger(fontSize));
runProperties.setSz(size);
runProperties.setSzCs(size);
}
}


/**
* @Description: 设置字体
*/
public void setFontFamily(RPr runProperties, String cnFontFamily,
String enFontFamily) {
if (StringUtils.isNotBlank(cnFontFamily)
|| StringUtils.isNotBlank(enFontFamily)) {
RFonts rf = runProperties.getRFonts();
if (rf == null) {
rf = new RFonts();
runProperties.setRFonts(rf);
}
if (cnFontFamily != null) {
rf.setEastAsia(cnFontFamily);
}
if (enFontFamily != null) {
rf.setAscii(enFontFamily);
}
}
}


/**
* @Description: 设置字体颜色
*/
public void setFontColor(RPr runProperties, String color) {
if (color != null) {
Color c = new Color();
c.setVal(color);
runProperties.setColor(c);
}
}


/**
* @Description: 设置字符边框
*/
public void addRPrBorderStyle(RPr runProperties, String size,
STBorder bordType, String space, String color) {
CTBorder value = new CTBorder();
if (StringUtils.isNotBlank(color)) {
value.setColor(color);
}
if (StringUtils.isNotBlank(size)) {
value.setSz(new BigInteger(size));
}
if (StringUtils.isNotBlank(space)) {
value.setSpace(new BigInteger(space));
}
if (bordType != null) {
value.setVal(bordType);
}
runProperties.setBdr(value);
}


/**
* @Description:着重号
*/
public void addRPrEmStyle(RPr runProperties, STEm emType) {
if (emType != null) {
CTEm em = new CTEm();
em.setVal(emType);
runProperties.setEm(em);
}
}


/**
* @Description: 空心
*/
public void addRPrOutlineStyle(RPr runProperties) {
BooleanDefaultTrue outline = new BooleanDefaultTrue();
outline.setVal(true);
runProperties.setOutline(outline);
}


/**
* @Description: 设置上标下标
*/
public void addRPrcaleStyle(RPr runProperties, STVerticalAlignRun vAlign) {
if (vAlign != null) {
CTVerticalAlignRun value = new CTVerticalAlignRun();
value.setVal(vAlign);
runProperties.setVertAlign(value);
}
}


/**
* @Description: 设置字符间距缩进
*/
public void addRPrScaleStyle(RPr runProperties, int indent) {
CTTextScale value = new CTTextScale();
value.setVal(indent);
runProperties.setW(value);
}


/**
* @Description: 设置字符间距信息
*/
public void addRPrtSpacingStyle(RPr runProperties, int spacing) {
CTSignedTwipsMeasure value = new CTSignedTwipsMeasure();
value.setVal(BigInteger.valueOf(spacing));
runProperties.setSpacing(value);
}


/**
* @Description: 设置文本位置
*/
public void addRPrtPositionStyle(RPr runProperties, int position) {
CTSignedHpsMeasure ctPosition = new CTSignedHpsMeasure();
ctPosition.setVal(BigInteger.valueOf(position));
runProperties.setPosition(ctPosition);
}


/**
* @Description: 阴文
*/
public void addRPrImprintStyle(RPr runProperties) {
BooleanDefaultTrue imprint = new BooleanDefaultTrue();
imprint.setVal(true);
runProperties.setImprint(imprint);
}


/**
* @Description: 阳文
*/
public void addRPrEmbossStyle(RPr runProperties) {
BooleanDefaultTrue emboss = new BooleanDefaultTrue();
emboss.setVal(true);
runProperties.setEmboss(emboss);
}


/**
* @Description: 设置隐藏
*/
public void setRPrVanishStyle(RPr runProperties, boolean isVanish) {
BooleanDefaultTrue vanish = runProperties.getVanish();
if (vanish != null) {
vanish.setVal(isVanish);
} else {
vanish = new BooleanDefaultTrue();
vanish.setVal(isVanish);
runProperties.setVanish(vanish);
}
}


/**
* @Description: 设置阴影
*/
public void addRPrShadowStyle(RPr runProperties) {
BooleanDefaultTrue shadow = new BooleanDefaultTrue();
shadow.setVal(true);
runProperties.setShadow(shadow);
}


/**
* @Description: 设置底纹
*/
public void addRPrShdStyle(RPr runProperties, STShd shdtype) {
if (shdtype != null) {
CTShd shd = new CTShd();
shd.setVal(shdtype);
runProperties.setShd(shd);
}
}


/**
* @Description: 设置突出显示文本
*/
public void addRPrHightLightStyle(RPr runProperties, String hightlight) {
if (StringUtils.isNotBlank(hightlight)) {
Highlight highlight = new Highlight();
highlight.setVal(hightlight);
runProperties.setHighlight(highlight);
}
}


/**
* @Description: 设置删除线样式
*/
public void addRPrStrikeStyle(RPr runProperties, boolean isStrike,
boolean isDStrike) {
// 删除线
if (isStrike) {
BooleanDefaultTrue strike = new BooleanDefaultTrue();
strike.setVal(true);
runProperties.setStrike(strike);
}
// 双删除线
if (isDStrike) {
BooleanDefaultTrue dStrike = new BooleanDefaultTrue();
dStrike.setVal(true);
runProperties.setDstrike(dStrike);
}
}


/**
* @Description: 加粗
*/
public void addRPrBoldStyle(RPr runProperties) {
BooleanDefaultTrue b = new BooleanDefaultTrue();
b.setVal(true);
runProperties.setB(b);
}


/**
* @Description: 倾斜
*/
public void addRPrItalicStyle(RPr runProperties) {
BooleanDefaultTrue b = new BooleanDefaultTrue();
b.setVal(true);
runProperties.setI(b);
}


/**
* @Description: 添加下划线
*/
public void addRPrUnderlineStyle(RPr runProperties,
UnderlineEnumeration enumType) {
U val = new U();
val.setVal(enumType);
runProperties.setU(val);
}


/*------------------------------------Word 相关---------------------------------------------------  */
/**
* @Description: 设置分节符 nextPage:下一页 continuous:连续 evenPage:偶数页 oddPage:奇数页
*/
public void setDocSectionBreak(WordprocessingMLPackage wordPackage,
String sectValType) {
if (StringUtils.isNotBlank(sectValType)) {
SectPr sectPr = getDocSectPr(wordPackage);
Type sectType = sectPr.getType();
if (sectType == null) {
sectType = new Type();
sectPr.setType(sectType);
}
sectType.setVal(sectValType);
}
}


/**
* @Description: 设置页面背景色
*/
public void setDocumentBackGround(WordprocessingMLPackage wordPackage,
ObjectFactory factory, String color) throws Exception {
MainDocumentPart mdp = wordPackage.getMainDocumentPart();
CTBackground bkground = mdp.getContents().getBackground();
if (StringUtils.isNotBlank(color)) {
if (bkground == null) {
bkground = factory.createCTBackground();
bkground.setColor(color);
}
mdp.getContents().setBackground(bkground);
}
}


/**
* @Description: 设置页面边框
*/
public void setDocumentBorders(WordprocessingMLPackage wordPackage,
ObjectFactory factory, CTBorder top, CTBorder right,
CTBorder bottom, CTBorder left) {
SectPr sectPr = getDocSectPr(wordPackage);
PgBorders pgBorders = sectPr.getPgBorders();
if (pgBorders == null) {
pgBorders = factory.createSectPrPgBorders();
sectPr.setPgBorders(pgBorders);
}
if (top != null) {
pgBorders.setTop(top);
}
if (right != null) {
pgBorders.setRight(right);
}
if (bottom != null) {
pgBorders.setBottom(bottom);
}
if (left != null) {
pgBorders.setLeft(left);
}
}


/**
* @Description: 设置页面大小及纸张方向 landscape横向
*/
public void setDocumentSize(WordprocessingMLPackage wordPackage,
ObjectFactory factory, String width, String height,
STPageOrientation stValue) {
SectPr sectPr = getDocSectPr(wordPackage);
PgSz pgSz = sectPr.getPgSz();
if (pgSz == null) {
pgSz = factory.createSectPrPgSz();
sectPr.setPgSz(pgSz);
}
if (StringUtils.isNotBlank(width)) {
pgSz.setW(new BigInteger(width));
}
if (StringUtils.isNotBlank(height)) {
pgSz.setH(new BigInteger(height));
}
if (stValue != null) {
pgSz.setOrient(stValue);
}
}


public SectPr getDocSectPr(WordprocessingMLPackage wordPackage) {
SectPr sectPr = wordPackage.getDocumentModel().getSections().get(0)
.getSectPr();
return sectPr;
}


/**
* @Description：设置页边距
*/
public void setDocMarginSpace(WordprocessingMLPackage wordPackage,
ObjectFactory factory, String top, String left, String bottom,
String right) {
SectPr sectPr = getDocSectPr(wordPackage);
PgMar pg = sectPr.getPgMar();
if (pg == null) {
pg = factory.createSectPrPgMar();
sectPr.setPgMar(pg);
}
if (StringUtils.isNotBlank(top)) {
pg.setTop(new BigInteger(top));
}
if (StringUtils.isNotBlank(bottom)) {
pg.setBottom(new BigInteger(bottom));
}
if (StringUtils.isNotBlank(left)) {
pg.setLeft(new BigInteger(left));
}
if (StringUtils.isNotBlank(right)) {
pg.setRight(new BigInteger(right));
}
}


/**
* @Description: 设置行号
* @param distance
*            :距正文距离 1厘米=567
* @param start
*            :起始编号(0开始)
* @param countBy
*            :行号间隔
* @param restartType
*            :STLineNumberRestart.CONTINUOUS(continuous连续编号)

*            STLineNumberRestart.NEW_PAGE(每页重新编号)

*            STLineNumberRestart.NEW_SECTION(每节重新编号)
*/
public void setDocInNumType(WordprocessingMLPackage wordPackage,
String countBy, String distance, String start,
STLineNumberRestart restartType) {
SectPr sectPr = getDocSectPr(wordPackage);
CTLineNumber lnNumType = sectPr.getLnNumType();
if (lnNumType == null) {
lnNumType = new CTLineNumber();
sectPr.setLnNumType(lnNumType);
}
if (StringUtils.isNotBlank(countBy)) {
lnNumType.setCountBy(new BigInteger(countBy));
}
if (StringUtils.isNotBlank(distance)) {
lnNumType.setDistance(new BigInteger(distance));
}
if (StringUtils.isNotBlank(start)) {
lnNumType.setStart(new BigInteger(start));
}
if (restartType != null) {
lnNumType.setRestart(restartType);
}
}


/**
* @Description：设置文字方向 tbRl 垂直
*/
public void setDocTextDirection(WordprocessingMLPackage wordPackage,
String textDirection) {
if (StringUtils.isNotBlank(textDirection)) {
SectPr sectPr = getDocSectPr(wordPackage);
TextDirection textDir = sectPr.getTextDirection();
if (textDir == null) {
textDir = new TextDirection();
sectPr.setTextDirection(textDir);
}
textDir.setVal(textDirection);
}
}


/**
* @Description：设置word 垂直对齐方式(Word默认方式都是"顶端对齐")
*/
public void setDocVAlign(WordprocessingMLPackage wordPackage,
STVerticalJc valignType) {
if (valignType != null) {
SectPr sectPr = getDocSectPr(wordPackage);
CTVerticalJc valign = sectPr.getVAlign();
if (valign == null) {
valign = new CTVerticalJc();
sectPr.setVAlign(valign);
}
valign.setVal(valignType);
}
}


/**
* @Description：获取文档的可用宽度
*/
public int getWritableWidth(WordprocessingMLPackage wordPackage)
throws Exception {
return wordPackage.getDocumentModel().getSections().get(0)
.getPageDimensions().getWritableWidthTwips();
}


} 
  

  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(文档操作,后端)

        

            

                
    
                    
  • Git的下载与安装及常用命令
                        小宝哥Code
Unity引擎git
                        
    Git的下载与安装指南Git是目前广泛使用的分布式版本控制系统，适用于代码管理和团队协作。以下是Git的下载与安装步骤。一、Git下载1.官方网站下载访问Git官方网站下载页面：GitDownloads，选择适合您操作系统的版本。2.选择操作系统Windows：点击下载Windows版本。MacOS：点击下载MacOS版本。Linux/Unix：根据发行版选择包管理器安装。二、Git安装1.Win
    
                    
    • 
                    
  • 14天速成小程序开发：第九章 首页banner轮播图效果的实现
                        雁于飞
14天速成小程序开发buguni-appvue微信小程序学习笔记后端
                        
    文章目录前言一、获取数据二、渲染样式三、成果展示四、代码展示1.index.vue页面1.1template1.2script1.3style2.utils.js公共逻辑前言本文将学习调用组件和接口文档实现首页banner轮播图效果的实现一、获取数据二、渲染样式三、成果展示四、代码展示1.index.vue页面1.1template点击右上角“添加到我的小程序”，方便下次找到！0"class="i
    
                    
    • 
                    
  • 深入剖析SolidWorks二维草图：三维设计的基石
                        小白是昏头仔
python开发语言
                        
    一、草图绘制工具基本绘图工具直线工具：这是最基础的绘图工具之一，通过简单的点击和拖动操作，用户能够绘制出各种直线段。在构建机械零件的基本框架时，直线工具十分常用。例如，绘制一个矩形的零件轮廓，只需依次点击四个顶点，即可快速勾勒出大致形状。而且，直线工具还支持连续绘制，用户可以不间断地绘制一系列首尾相连的直线，用于创建多边形等复杂形状。圆工具：用于创建圆形几何图形。在设计包含孔洞、圆形连接件或齿轮等
    
                    
    • 
                    
  • Transformer中query、key和value的状态为什么要是 contiguous？
                        AI老兵
transformer深度学习人工智能知识图谱agiAIGC
                        
    Transformer中query、key和value的状态为什么要是contiguousd值？在阅读Transformer模型的相关代码时，会发现query、key和value都会有contiguous()化操作，如下所示：...query_states=query_states.contiguous()key_states=key_states.contiguous()value_states
    
                    
    • 
                    
  • 在K8S中，如果后端NFS存储的IP发送变化如何解决？
                        Dusk_橙子
K8Skubernetestcp/ip容器
                        
    在Kubernetes中，如果后端NFS存储的IP地址发生了变化，您需要更新与之相关的PeristentVolume(PV)或PersistentVolumeClaim(PVC)以及StorageClass中关于NFS服务器IP的配置信息，确保K8S集群内的Pod能够正确连接到新的NFS存储位置。解决方案如下：更新PersistentVolume(PV)：如果你直接在PV中指定了NFS服务器的IP
    
                    
    • 
                    
  • 大模型GUI系列论文阅读 DAY3：《GPT-4V(ision) is a Generalist Web Agent, if Grounded》
                        feifeikon
论文阅读
                        
    摘要近年来，大型多模态模型（LMMs）的发展，特别是GPT-4V(ision)和Gemini，迅速扩展了多模态模型的能力边界，不再局限于传统任务如图像描述和视觉问答。在本研究中，我们探讨了LMMs（如GPT-4V）作为通用网页代理的潜力，这类代理能够根据自然语言指令完成任意网站上的任务。我们提出了SEEACT，这是一种通用网页代理，利用LMMs的视觉理解能力，实现网页上的操作。我们在最新的MIND
    
                    
    • 
                    
  • Java 封装与继承：面向对象编程的两大支柱
                        来恩1003
Java从入门到精通java开发语言
                        
    Java学习资料Java学习资料Java学习资料引言在Java的面向对象编程（OOP）体系里，封装和继承是极为关键的概念。它们不仅是构建复杂软件系统的基础，也为代码的设计、维护与扩展提供了强大助力。接下来，我们将深入探究这两大支柱的内涵、实现方式及其在实际开发中的价值。封装封装的定义封装是把对象的属性和操作这些属性的方法捆绑在一起，形成一个独立的单元，并尽可能隐藏对象的内部实现细节，只向外部提供必
    
                    
    • 
                    
  • 通过手机控制家用电器的一个程序的设计（一）
                        zhumin726
智能家居智能家居
                        
    一、概述设计一款安卓平台上的家庭智能控制软件，通过语音识别指令控制家用电器。该软件结合离线语音识别技术、红外线和WIFI通讯技术，实现对家电的智能控制，如开关机、调温度、调频道等操作。二、主要功能模块离线语音识别模块功能：识别用户的语音指令。技术：使用离线语音识别API，如PocketSphinx或Kaldi。操作流程：用户说出指令→语音数据被传输到离线语音识别引擎→引擎返回文本指令。命令解析模块
    
                    
    • 
                    
  • Python开发接水果小游戏
                        YhPythonJSCPP
【游戏开发】【Python】python游戏开发pylash
                        
    我研发的Python游戏引擎Pylash已经更新到1.4了。现在我们就来使用它完成一个极其简单的小游戏：接水果。以下是游戏截图：游戏操作说明：点击屏幕左右两边或者使用键盘方向键控制人物移动，使人物与水果接触得分，碰到非水果的物品，如碎玻璃，就会gameover。接下来是详尽的开发过程，篇幅较长，请看官耐心阅读。Pylash项目地址由于本次开发用到了pylash，大家可以先去Github上对引擎进行
    
                    
    • 
                    
  • 云计算相关
                        xianKOG
云计算云计算
                        
    文章目录一、虚拟化1、虚拟化技术概述特点2、虚拟化与云化3、计算虚拟化分类与作用常见的计算服务架构4、存储虚拟化5、网络虚拟化二、行业管理规章制度1、服务器管理制度访问控制变更管理备份与恢复监控与审计2、操作系统安全管理规范更新与补丁管理用户账号管理防火墙与安全软件日志管理3、虚拟化管理规定资源分配隔离策略模版与镜像三、操作系统1、操作系统安装2、操作系统调优3、操作系统管理维护4、常见服务安装与
    
                    
    • 
                    
  • 嵌入式基础篇--了解和搭建开发环境
                        雯宝
microsoft
                        
    文章目录1.开发环境搭建2.LinuxC编程入门3.ARMV7和ARMV8架构4.ARM汇编5.BSP工程管理1.开发环境搭建1.虚拟机Vmware的安装：在PC主机下安装Linux系统，方便切换windows和Linux系统2.在虚拟机Vmware中安装Ubuntu操作系统：便于基于Linux系统的开发3.Ubuntu交叉编译工具链安装4.SourceInsight安装：用于在Windows下代
    
                    
    • 
                    
  • python红包游戏_脑力2048红包版
                        影智
python红包游戏
                        
    脑力2048红包版是一款最新推出的非常好玩的手机2048闯关赢红包小游戏,在脑力2048红包版游戏中玩家可以通过2048的玩法来进行闯关,游戏玩法非常的简单有趣,成功通过关卡就有机会获得现金红包,感兴趣的朋友赶紧下载脑力2048红包版开始游戏吧!脑力2048红包版游戏特色1、经典2048玩法带玩家找回童年的感觉，指尖操作探险数字之间的关系。2、全新主题挑战模式，全部解锁12种主题，最有趣的宫廷版2
    
                    
    • 
                    
  • 从理论到实践：Django 业务日志配置与优化指南
                        ivwdcwso
开发运维安全djangopython日志开发配置
                        
    在现代Web开发中，日志记录是确保系统可维护性和可观测性的重要手段。通过合理的日志配置，我们可以快速定位问题、分析系统性能，并进行安全审计。本文将围绕Django框架，详细介绍如何配置和优化业务日志，确保开发环境和生产环境都能高效地记录和管理日志。©ivwdcwso(ID:u012172506)1.日志的重要性日志是系统运行的“黑匣子”，记录了系统的关键操作、错误信息和性能数据。合理使用日志可以帮
    
                    
    • 
                    
  • c语言小项目——通讯录实现
                        xxGUA_
学习c语言学习
                        
    一、功能的介绍实现通讯录中联系人信息的增、删、查、改。二、程序模块的介绍1.测试文件test.c初始化通讯录—>联系人的增、删、查、改—>每次操作之后都打印通讯录。#include"contact.h"intmain(){intinput=0;structcontactcon;//通讯录结构体变量menu();//菜单initcontact(&con);//初始化通讯录while(1){print
    
                    
    • 
                    
  • C语言程序设计——手机通讯录系统
                        green qwq
C和C++语言程序综合设计实践c语言
                        
    题目【难度系数】3级【任务描述】模拟手机通信录管理系统，实现对个人通信录的管理。【功能描述】通讯录信息管理：包括添加、删除、修改、查询、保存、浏览等操作。通讯录信息主要包括：编号、姓名、电话号码、分类（例如包括：A办公类；B个人类；C商务类等）、电子邮件、生日等。具体信息可参照设计者的手机通讯录结构。查询功能：选择此功能时，列出用户类别，例如：A办公类；B个人类；C商务类。根据选中的类别，显
    
                    
    • 
                    
  • WPF实现全屏显示——遮挡任务栏/不遮挡任务栏
                        敲代码的TKP
wpf
                        
    不遮挡任务栏实现全屏显示//在后端代码中设置this.WindowState=System.Windows.WindowState.Normal;this.WindowStyle=System.Windows.WindowStyle.None;this.ResizeMode=System.Windows.ResizeMode.NoResize;this.Topmost=true;this.Left
    
                    
    • 
                    
  • 基于遗传算法的城市旅行问题（TSP）求解
                        NovakG_
深度学习python算法深度学习神经网络
                        
    1.遗传算法背景介绍遗传算法是一种基于生物进化论中的自然选择和遗传机制的优化算法，模拟了生物进化过程以搜索最优解。通过仿真染色体的交叉、变异等操作，遗传算法将求解过程转换为类似生物进化的迭代运算。该算法在解决复杂的组合优化问题时，通常比常规优化算法更高效，且具有广泛应用，包括组合优化、机器学习、信号处理、自适应控制和人工生命等领域2.遗传算法基本解题思路遗传算法的设计思路主要受到大自然中生物体进化
    
                    
    • 
                    
  • Objective-C语言的安全开发
                        萧澄华
包罗万象golang开发语言后端
                        
    Objective-C语言的安全开发引言在当今的信息技术时代，软件的安全性已成为开发者必须重视的重点。随着移动互联网的蓬勃发展，iOS作为重要的移动操作系统，受到越来越多开发者的关注。而Objective-C作为iOS应用开发的主要语言之一，其安全性问题也应引起重视。本文将探讨在Objective-C语言中进行安全开发的最佳实践，帮助开发者在应用编程过程中减少安全隐患，提高应用的安全性。一、了解O
    
                    
    • 
                    
  • Python 入门路线（2025 极简无废话版）
                        墨鱼爆蛋
Pythonpython开发语言编程
                        
    大家好，梳理一个Python从入门到精通路线大家都挺忙的，突出一个无废话注：时间仅供参考第一阶段：基础入门(0-3个月)1.Python基础语法开发环境搭建(Python安装、IDE选择)变量和数据类型运算符和表达式控制流(if/else、循环)函数定义与调用基本输入输出2.数据结构基础列表(List)和元组(Tuple)字典(Dict)和集合(Set)字符串处理文件操作3.错误处理try/exc
    
                    
    • 
                    
  • Python 上下文管理器：优雅地管理资源
                        墨鱼爆蛋
python开发语言数据库
                        
    一、什么是上下文管理器上下文管理器是一个可以在with语句中使用的对象，它定义了__enter__和__exit__方法，它定义了在进入和退出特定代码块时需要执行的操作，确保资源在使用完毕后能够被正确地释放或清理。二、如何实现上下文管理器Python的上下文管理器通常通过两种方式实现：一种是使用类，另一种是使用生成器。1.使用类实现上下文管理器要实现一个自定义的上下文管理器类，你需要在类中定义两个
    
                    
    • 
                    
  • Vue全家桶 - 电商后台管理系统项目开发实录（详）
                        ←か淡定☆ ヾ
前端vue.jsjavascripthtml5node.jscss3
                        
    目录1.项目概述1.1电商项目基本业务概述1.2电商后台管理系统的功能1.3电商后台管理系统的开发模式（前、后端分离）2.项目初始化2.1前端项目初始化步骤码云相关操作2.2后台项目的环境安装配置3.登录/退出功能3.1登录概述3.2登录-token原理分析3.3实现登录功能3.4实现退出功能处理ESLint警告4.主页布局4.1后台首页基本布局4.2顶部布局，侧边栏布局4.2.1.顶部布局4.2
    
                    
    • 
                    
  • 【Python百日进阶-Web开发-Feffery】Day604 - 趣味dash_04：Excel转Pdf文件
                        岳涛@泰山医院
Dashpythonexcel前端dash
                        
    文章目录一、环境准备1.1初始化基础`Python+Dash`环境1.2本例中使用的第三方包二、本项目B站视频讲解三、页面效果四、项目源码一、环境准备1.1初始化基础Python+Dash环境CSDN文档参见：https://blog.csdn.net/yuetaope/article/details/129795264Bilibili视频参见：https://www.bilibili.com/v
    
                    
    • 
                    
  • Python进阶--Python操作excel
                        小昀小杭
pythonexcel数据库
                        
    一、xlsxwirter三方库优点：写的快功能多缺点：只能写问题：内容并不是直接写入文件中只有在关闭的时候才会写入文件实例：#创建excel文件wb=xlsxwriter.Workbook("cars.xlsx")#在该文件下创建sheetws=self.wb.get_worksheet_by_name("Car")orself.wb.add_worksheet("Car")ws.write(ro
    
                    
    • 
                    
  • 【python进阶】txt excel pickle opencv操作demo
                        闪闪发亮的小星星
AI算法工程师打怪pythonexcelopencv
                        
    文章目录1.txt读写读综合案例日志文件读写2.excel读写读取csv读取xlsx3.matplotlib案例折线图多个折现图散点图柱状图饼状图4opencv案例加载与展示图片缩放图片旋转图片保存图片读取摄像头视频保存opencv综合案例5pickle案例1.txt读写读file.read()file.readlines()file.readline()##使用'read'方法读取文件的所有内容
    
                    
    • 
                    
  • 我的ROS学习笔记（四）
                        zenpluck
自动驾驶c++
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档publisher程序代码学习前言一、包含消息类型声明二、创建发布者对象三、创建并填充消息对象四、发布消息五、消息发布循环1.节点是否停止工作的检查2.控制消息发布频率总结前言发布者程序包含了很多之前不懂的知识，刚开始也许只能复制粘贴代码来运行实例，但最终目的还是为了自己能够编写这些代码。因此，弄明白哪部分代码是什么意思非常有必要，不
    
                    
    • 
                    
  • 【YashanDB知识库】非YCM方式的自动备份方案示例
                        
数据库
                        
    本文内容来自YashanDB官网，原文内容请见https://www.yashandb.com/newsinfo/7281310.html?templateId=171...概述如果有YCM，推荐使用YCM自动备份，详情请参考YCM官方文档。但是如果没有YCM，则可通过crontab实现自动备份。目前示例的自动备份方案是每周的周3、周6的凌晨0点做全量备份；每天的凌晨2点做增量备份；每天的凌晨4点
    
                    
    • 
                    
  • python+Selenium自动化之免登录(cookie及token)
                        觅远
pythonselenium自动化
                        
    目录cookie免登录通过接口获取cookie启用浏览器绕过登录添加token使用登录可以减去每次登录的重复操作，直接操作系统登录后的菜单页面，也可以减少安全验证登录，如图像验证登录的操作。注意：cookie和token都有有效期。cookie免登录直接从开发者工具中获取cookie进行添加，下图为网页中多个站点的cookie，挑选需要的进行添加即可。fromseleniumimportwebdr
    
                    
    • 
                    
  • Linux-Ubuntu入门笔记
                        LeoJamLin
linuxlinux
                        
    一.linux操作系统概述1.常见操作系统-服务端操作系统：linux、unix、windowsserver-单机操作系统：windows（dos、ucdos、win95、win98、win2000、xp、vista、win7、win8）MAC、linux（ubuntu）-移动操作系统Android、IOS、Windowsphone2.linux操作系统介绍-为什么要学习linux操作系统1.大部
    
                    
    • 
                    
  • 【2025 ODA teigha .NET系列开发教程 第五章】给CAD实体添加附属数据XDATA，包括源码
                        三好学生～张旺
ODATeigha.NET开发教程.net
                        
    系列文章目录提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加例如：第一章Python机器学习入门之pandas的使用提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档2025ODAteigha.NET系列开发教程系列文章目录AutoCADXData扩展数据开发指南什么是XData？XData的两种存储方式1.全局字典存储(XRecord)2.实体附加存储步骤1：注册应
    
                    
    • 
                    
  • 创建和管理用户
                        远歌已逝
数据库oracle数据库
                        
    学习目标创建新的数据库用户修改和删除现有的数据库用户监控现有用户的信息获取用户信息以下是基于MySQL数据库管理系统的操作步骤和示例，这些概念也可以适用于其他数据库系统，如PostgreSQL、SQLServer、Oracle等。1.创建新的数据库用户在MySQL中创建新用户，可以使用以下SQL语句：CREATEUSER'username'@'hostname'IDENTIFIEDBY'passw
    
                    
    • 
                                
  • apache ftpserver-CentOS config
                                    gengzg
apache
                                    
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://mina.apache.o
    
                                
    • 
                                
  • 优化MySQL数据库性能的八种方法
                                    AILIKES
sqlmysql
                                    
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    
                                
    • 
                                
  • JeeSite 企业信息化快速开发平台
                                    Kai_Ge
JeeSite
                                    
    JeeSite 企业信息化快速开发平台  
平台简介 
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    
                                
    • 
                                
  • 通过Spring Mail Api发送邮件
                                    120153216
邮件main
                                    
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 
Spring Mail API都在org.spri
    
                                
    • 
                                
  • Pysvn 程序员使用指南
                                    2002wmj
SVN
                                    
    源文件:http://ju.outofmemory.cn/entry/35762 
这是一篇关于pysvn模块的指南. 
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. 
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 
该
    
                                
    • 
                                
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
                                    357029540
SQL Server
                                    
    SELECT  R.session_id AS BlockedSessionID ,  
        S.session_id AS BlockingSessionID ,  
        Q1.text AS Block
    
                                
    • 
                                
  • Intent 常用的用法备忘
                                    7454103
.netandroidGoogleBlogF#
                                    
    Intent 
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 
 
下面列出几种Intent 的用法 
显示网页: 
 

    
                                
    • 
                                
  • Spring定时器时间配置
                                    adminjun
spring时间配置定时器
                                    
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />  
测试的时候，由于是每天定时执行，所以后面三个数
    
                                
    • 
                                
  • POJ 2421 Constructing Roads 最小生成树
                                    aijuans
最小生成树
                                    
    来源：http://poj.org/problem?id=2421 
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 
代码： 
 
#include <iostream>
#include <cstdio>
    
                                
    • 
                                
  • 重构笔记——提取方法（Extract Method）
                                    ayaoxinchao
java重构提炼函数局部变量提取方法
                                    
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。 
  
下面是我学习这个重构手法的笔记： 
  
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    
                                
    • 
                                
  • 为UILabel添加点击事件
                                    bewithme
UILabel
                                    
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。 
  
  UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
                                    bijian1013
redis数据库NoSQL
                                    
    一.redis.php 
<?php
      //实例化
      $redis = new Redis();
      //连接服务器
      $redis->connect("localhost");
      //授权
      $redis->auth("lamplijie");
      //相关操
    
                                
    • 
                                
  • SecureCRT使用备注
                                    bingyingao
secureCRT每页行数
                                    
    SecureCRT日志和卷屏行数设置 
 
一、使用securecrt时，设置自动日志记录功能。 
 
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 
 
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    
                                
    • 
                                
  • 【Scala九】Scala核心三：泛型
                                    bit1129
scala
                                    
    泛型类 
package spark.examples.scala.generics

class GenericClass[K, V](val k: K, val v: V) {
  def print() {
    println(k + "," + v)
  }
}

object GenericClass {
  def main(args: Arr
    
                                
    • 
                                
  • 素数与音乐
                                    bookjovi
素数数学haskell
                                    
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。 
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-IdentityHashMap
                                    BrokenDreams
Collections
                                    
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。 
        简单的说，IdentityHashMap和HashM
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 



import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    
                                
    • 
                                
  • PS人像润饰&调色教程集锦
                                    cherishLC
PS
                                    
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 
 
http://www.howzhi.com/course/retouching/ 
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。 
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    
                                
    • 
                                
  • 更新多个字段的UPDATE语句
                                    crabdave
update
                                    
    更新多个字段的UPDATE语句 
  
                 
                update tableA a
                   set (a.v1, a.v2, a.v3, a.v4) =   --使用括号确定更新的字段范围
          
    
                                
    • 
                                
  • hive实例讲解实现in和not in子句
                                    daizj
hivenot inin
                                    
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 
 
 
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 
 
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    
                                
    • 
                                
  • 一道24点的10+种非人类解法（2,3,10,10）
                                    dsjt
算法
                                    
    这是人类算24点的方法？！！！ 
 
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 
 
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 
 
然后么。。。我就在深夜很得瑟的问室友求室友算 
 
刚出完题，文哥的暴走之旅开始了 
 
5秒后
    
                                
    • 
                                
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
                                    dcj3sjt126com
yiiframework
                                    
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    
                                
    • 
                                
  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
                                    come_for_dream
对象
                                    
    概述 
  
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。 
  
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    
                                
    • 
                                
  • 学习编程那点事
                                    gcq511120594
编程互联网
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • Reverse Linked List II
                                    hcx2013
list
                                    
    Reverse a linked list from position m to n. Do it in-place and in one-pass. 
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, 
return 
    
                                
    • 
                                
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Hadoop集群工具distcp
                                    liyonghui160com

                                    
      
  
1. 环境描述 
两个集群：rock 和 stone 
rock无kerberos权限认证，stone有要求认证。 
1. 从rock复制到stone，采用hdfs 
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    
                                
    • 
                                
  • 一个备份MySQL数据库的简单Shell脚本
                                    pda158
mysql脚本
                                    
    　　主脚本（用于备份mysql数据库）：   　　该Shell脚本可以自动备份 
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。   　　 
1. 分别建立目录“backup”和“oldbackup”   　　#mkdir /backup   　　#mkdir /oldbackup   　
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
                                    shoothao
IT资源图标库图片库色彩板字体
                                    
     
 A. 免费的设计资源 
 
 
  Freebbble:来自于Dribbble的免费的高质量作品。 
  Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 
  Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 
  Pixel Buddha:免费和优质资源的专业社区。 
  Premium Pixels:为那些有创意的人提供免费的素材。 
  
    
                                
    • 
                                
  • thrift总结 - 跨语言服务开发
                                    uule
thrift
                                    
    官网 
官网JAVA例子 
thrift入门介绍 
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 
Thrift入门及Java实例演示 
thrift的使用介绍 
  
RPC  
  
POM： 
<dependency>
  <groupId>org.apache.thrift</groupId>
  
    
                                
    •