写毕业论文时，遇到自定义目录格式不生效的问题，一番搜索后，终于还是靠自己解决了这个问题，特此记录一下。
 
问题描述：正文部分设置了三级标题，如图1-1所示，在自定义目录格式时，设置了目录1（TOC1）格式为小四宋体加粗，目录2（TOC2）和目录3（TOC3）格式为小四宋体常规，生成的目录如图1-2所示，发现目录格式并不是自己定义的格式。
 
 图1-1 正文三级标题格式
 

 图1-2 生成自定义目录
 
解决方法：经过试验发现，自己在设置正文标题时，直接选中了word提供的“标题1”、“标题2”和“标题3”样式，由于这些默认样式的格式跟自己的需求不同，于是我直接在正文标题处设置了字体格式，而不是修改word提供的“标题1”、“标题2”和“标题3”的样式。这是造成我自定义目录格式不生效的原因。发现了这一点后，找到了两种解决方法：
 1、直接对word提供的这三个标题样式进行修改。
 首先，全选中正文1级标题（第一章 小三黑体加粗），在开始菜单栏的样式栏中发现“标题1”被选中，右击后点击修改，将标题1样式设置为自己需要的格式。对正文2级和3级标题做同样的操作。至此，更新目录或者重新添加自定义目录后，得到的目录格式就是之前设置的格式了，如图1-4所示，目录格式变成小四宋体了。
 
 图1-3 修改标题样式
 
 图1-4 最终得到了想要的自定义目录格式
 2、自己创建三个标题样式。
 这个方法原理与方法1是相同的。在样式栏中点击其他按钮，然后点击创建样式，样式名称可以自己定义，点击修改，修改完格式后，再定义正文标题时就可以直接使用自己创建的样式了。至此，自定义目录的格式也能生效了。如果要修改正文标题的格式，可以直接修改自定义的标题样式。
 
 图1-5 添加自定义样式按钮
 
 图1-6 创建样式
 
设置样式格式时，最好将添加到样式库和自动更新勾上。
 
 图1-7 设置样式的格式

弄了两个小时的目录格式，就是为了一键生成！
 总结一下，记录一下避免以后犯同样的错误
 使用的是word2016
 
1.设置自定义目录
 
 
2.设置样式
 
格式一定要选择来自模板！！！！！要不然修改按钮不会亮！！！
 
3.修改一级标题的格式
 

 点击修改后
 
 按照毕业论文格式要求，设置他的格式，里面有一个比较容易忽视的点，就是制表位的设置
 主要是为了让页码向右对齐
 
 制表位的位置我之前设置多个好像是没用的，最好设置一个
 其他二级三级或者以下目录都是这样设置的
 
到这里就结束了，点击引用中的更新目录
 
 然后就变成想要的目录格式的目录啦
 

 
文章目录
 
自定义输入需求
先来看看底层的map方法
编写自定义输入格式
编写自定义记录读取器
Mapper类
Reducer类
设置Driver
执行结果
   
自定义输出需求
实现代码
  
 

 
自定义输入需求
 
将下面的三个文件的内容读取到一个SequenceFile中，SequenceFile是hadoop中特有的文件格式，适合key-value的存储。比普通文件格式节省空间。现在默认的输出格式是TextOutputFormat(文本格式的输出)，改为SequenceFileOutputFormat。将输入目录的文件读取key-value(bytes)形式，将文件的内容读取封装为bytes类型，然后将文件名作为key。
 
 
 
先来看看底层的map方法
 
下面的方法最重要的就是nextKeyValue();此方法的内部实现将我们需要的值设为key和value，所以我们要重写该方法。
 
使用maptask的runNewMapper方法开始正式的map阶段
    1、根据自定义map类名，获得自定义map对象
    2、调用Mapper的run函数来运行用户自定义的map方法
        //设置相关变量或者参数，一个map只调用一次
        setup(context);
        try {
          while (context.nextKeyValue()) {
        //使用while循环调用自定义map的方法
        map(context.getCurrentKey(), context.getCurrentValue(), context);
          }
        } finally {
          //清理过程，包括清理一些没用的k-v
          cleanup(context);
        }
 
编写自定义输入格式
 
import java.io.IOException;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

/*
 * 1. 改变切片策略，一个文件固定切1片，通过指定文件不可切
 * 
 * 2. 提供RecordReader ，这个RecordReader读取切片的文件名作为key,读取切片的内容封装到bytes作为value
 */
public class MyInputFormat extends FileInputFormat {

	@Override
	public RecordReader createRecordReader(InputSplit split, TaskAttemptContext context)
			throws IOException, InterruptedException {
		
		return new MyRecordReader();
	}
	
	// 重写isSplitable
	@Override
	protected boolean isSplitable(JobContext context, Path filename) {
		
		return false;
	}
	
	

}
 
编写自定义记录读取器
 
该部分重写nextKeyValue()方法。然后在initialize中初始化一些我们需要的值。
 
import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

/*
 * RecordReader从MapTask处理的当前切片中读取数据
 * 
 * XXXContext都是Job的上下文，通过XXXContext可以获取Job的配置Configuration对象
 */
public class MyRecordReader extends RecordReader {
	
	private Text key;
	private BytesWritable value;
	
	private String filename;
	private int length;
	
	private FileSystem fs;
	private Path path;
	
	private FSDataInputStream is;
	
	private boolean flag=true;

	// MyRecordReader在创建后，在进入Mapper的run()之前，自动调用
	// 文件的所有内容设置为1个切片，切片的长度等于文件的长度
	@Override
	public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {

		FileSplit fileSplit=(FileSplit) split;
		
		filename=fileSplit.getPath().getName();
		
		length=(int) fileSplit.getLength();
		
		path=fileSplit.getPath();
		
		//获取当前Job的配置对象
		Configuration conf = context.getConfiguration();
		
		//获取当前Job使用的文件系统
		fs=FileSystem.get(conf);
		
		 is = fs.open(path);
		
	}

	// 读取一组输入的key-value，读到返回true,否则返回false
	// 将文件的名称封装为key，将文件的内容封装为BytesWritable类型的value，返回true
	// 第二次调用nextKeyValue()返回false
	@Override
	public boolean nextKeyValue() throws IOException, InterruptedException {
		
		if (flag) {
			
			//实例化对象
			if (key==null) {
				key=new Text();
			}
			
			if (value==null) {
				value=new BytesWritable();
			}
			
			//赋值
			//将文件名封装到key中
			key.set(filename);
			
			// 将文件的内容读取到BytesWritable中
			byte [] content=new byte[length];
			
			IOUtils.readFully(is, content, 0, length);
			
			value.set(content, 0, length);
			
			flag=false;
			
			return true;
			
		}
		
		return false;
	}

	//返回当前读取到的key-value中的key
	@Override
	public Object getCurrentKey() throws IOException, InterruptedException {
		return key;
	}

	//返回当前读取到的key-value中的value
	@Override
	public Object getCurrentValue() throws IOException, InterruptedException {
		return value;
	}

	//返回读取切片的进度
	@Override
	public float getProgress() throws IOException, InterruptedException {
		return 0;
	}

	// 在Mapper的输入关闭时调用，清理工作
	@Override
	public void close() throws IOException {
		if (is != null) {
			IOUtils.closeStream(is);
		}
		
		if (fs !=null) {
			fs.close();
		}
	}

}
 
Mapper类
 
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class CustomIFMapper extends Mapper<Text, BytesWritable, Text, BytesWritable>{

}
 
Reducer类
 
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class CustomIFReducer extends Reducer<Text, BytesWritable, Text, BytesWritable>{

}
 
设置Driver
 
import java.io.IOException;
import java.net.URI;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.SequenceFileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;

public class CustomIFDriver {
	
	public static void main(String[] args) throws Exception {
		
		Path inputPath=new Path("C:\\Users\\Lenovo\\Desktop\\PPT\\input");
		Path outputPath=new Path("C:\\Users\\Lenovo\\Desktop\\PPT\\output");
		

		//作为整个Job的配置
		Configuration conf = new Configuration();
		//保证输出目录不存在
		FileSystem fs=FileSystem.get(conf);
		
		if (fs.exists(outputPath)) {
			
			fs.delete(outputPath, true);
			
		}
		
		// ①创建Job
		Job job = Job.getInstance(conf);
		
		job.setJarByClass(CustomIFDriver.class);
		
		
		// 为Job创建一个名字
		job.setJobName("wordcount");
		
		// ②设置Job
		// 设置Job运行的Mapper，Reducer类型，Mapper,Reducer输出的key-value类型
		job.setMapperClass(CustomIFMapper.class);
		job.setReducerClass(CustomIFReducer.class);
		
		// Job需要根据Mapper和Reducer输出的Key-value类型准备序列化器，通过序列化器对输出的key-value进行序列化和反序列化
		// 如果Mapper和Reducer输出的Key-value类型一致，直接设置Job最终的输出类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(BytesWritable.class);
		
		// 设置输入目录和输出目录
		FileInputFormat.setInputPaths(job, inputPath);
		FileOutputFormat.setOutputPath(job, outputPath);
		
		// 设置输入和输出格式
		job.setInputFormatClass(MyInputFormat.class);
		job.setOutputFormatClass(SequenceFileOutputFormat.class);
		
		// ③运行Job
		job.waitForCompletion(true);
		
		
	}

}

 
执行结果
 

 
 
自定义输出需求
 

 
 需求
 过滤输入的log日志，包含baidu的网站输出到e:/baidu.log，不包含baidu的网站输出到e:/other.log。
 
实现代码
 
Mapper
 
/*
 * 1.什么时候需要Reduce
 * 		①合并
 * 		②需要对数据排序
 * 
 * 2. 没有Reduce阶段，key-value不需要实现序列化
 */
public class CustomOFMapper extends Mapper<LongWritable, Text, String, NullWritable>{
	
	@Override
	protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, String, NullWritable>.Context context)
			throws IOException, InterruptedException {
	
		String content = value.toString();
		
		context.write(content+"\r\n", NullWritable.get());
		
	}

}
 
自定义outputformat
 
public class MyOutPutFormat extends FileOutputFormat<String, NullWritable>{

	@Override
	public RecordWriter<String, NullWritable> getRecordWriter(TaskAttemptContext job)
			throws IOException, InterruptedException {
		return new MyRecordWriter(job);
	}

}
 
自定义记录写出
 
public class MyRecordWriter extends RecordWriter<String, NullWritable> {
	
	private Path baiduPath=new Path("e:/baidu.log");
	private Path otherPath=new Path("e:/other.log");
	
	private FSDataOutputStream baiduOS ;
	private FSDataOutputStream otherOS ;
	
	private FileSystem fs;
	
	private TaskAttemptContext context;

	public MyRecordWriter(TaskAttemptContext job) throws IOException {
		
			context=job;
		
			Configuration conf = job.getConfiguration();
			
			fs=FileSystem.get(conf);
			
			 baiduOS = fs.create(baiduPath);
			 otherOS = fs.create(otherPath);
	}
	

	// 负责将key-value写出到文件
	@Override
	public void write(String key, NullWritable value) throws IOException, InterruptedException {
		
		if (key.contains("baidu")) {
			
			baiduOS.write(key.getBytes());
			
			
			
		}else {
			
			otherOS.write(key.getBytes());
			
		}
		
	}

	// 关闭操作
	@Override
	public void close(TaskAttemptContext context) throws IOException, InterruptedException {
		
		if (atguguOS != null) {
			IOUtils.closeStream(baiduOS);
		}
		
		if (otherOS != null) {
			IOUtils.closeStream(otherOS);
			
		}
		
		if (fs != null) {
			fs.close();
		}
		
	}

}
 
driver
 
public class CustomOFDriver {
	
	public static void main(String[] args) throws Exception {
		
		Path inputPath=new Path("e:/mrinput/outputformat");
		Path outputPath=new Path("e:/mroutput/outputformat");
		

		//作为整个Job的配置
		Configuration conf = new Configuration();
		//保证输出目录不存在
		FileSystem fs=FileSystem.get(conf);
		
		if (fs.exists(outputPath)) {
			
			fs.delete(outputPath, true);
			
		}
		
		// ①创建Job
		Job job = Job.getInstance(conf);
		
		job.setJarByClass(CustomOFDriver.class);
		
		
		// 为Job创建一个名字
		job.setJobName("wordcount");
		
		// ②设置Job
		// 设置Job运行的Mapper，Reducer类型，Mapper,Reducer输出的key-value类型
		job.setMapperClass(CustomOFMapper.class);
		
		// 设置输入目录和输出目录
		FileInputFormat.setInputPaths(job, inputPath);
		FileOutputFormat.setOutputPath(job, outputPath);
		
		// 设置输入和输出格式
		job.setOutputFormatClass(MyOutPutFormat.class);
		
		// 取消reduce阶段
		job.setNumReduceTasks(0);
		
		// ③运行Job
		job.waitForCompletion(true);
		
		
	}

}

由于日志管理需要整合到统一的日志管理平台，所以集群部署的多台服务器日志会冲突，老板要求在日志路径及日志文件中加上服务器IP加以区分，此为前要。
 
 
首先说一下为什么不用MDC赋值来操作：MDC赋值其实也可以达到区分路劲和在文件中加Ip的目的，但是代码倾入大，需要动底层框架上已经封装好的业务jar包，因此首先pass。
 百度后有大神说整一个logback自定义格式转换器，也就是继承ClassicConverter，实现他的convert方法，然后配置在xml中配置conversionRule标签，即可获取自定义的值，亲测后发现该方式只能在文件中（Pattern）获取到自定义的值，而路径中（FileNamePattern）无法获取到值，创建的路径为***/%PARSER_ERROR[***]/***，因此该方式不能满足需求。但是该方式文件中使用还是方便的，因此附上我自己的实现；
 
// 新建java类
package *****.****.util.logback;

import ch.qos.logback.classic.pattern.ClassicConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 该工具类用于在logback中通过%IP获取节点IP地址(日志文件内容),该类需要配置在logback中conversionRule标签
 */
public class NodeIpConverter extends ClassicConverter {
    private static String nodeIP;
    static {
        try {
            nodeIP = InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
    @Override
    public String convert(ILoggingEvent event) {
        return nodeIP;
    }
}

// logback.xml添加以下配置，该配置位于configuration标签下
<conversionRule conversionWord="nodeIp" converterClass="***.***.util.logback.NodeIpConverter"/>
该方式引用时为 %nodeIp

 
一路不同再找一路，再次寻求度娘，发现通过自定义全局属性可以实现在路径中动态获取IP值，柳暗花明啊，而且经过测试发现该方式不仅可以在路径（FileNamePattern）中动态获取服务器IP,同时日志输出文件中（Pattern）也可以使用，下面奉上代码：
 
// 新建java类继承PropertyDefinerBase，重写getPropertyValue方法
package ***.***.util.logback;

import java.net.InetAddress;
import java.net.UnknownHostException;
import ch.qos.logback.core.PropertyDefinerBase;

/**
 * 该工具类用于在logback中通过%IP获取节点IP地址(日志文件路劲),该类需要配置在logback中conversionRule标签
 */
public class NodeIpProperty extends PropertyDefinerBase {
    private static String nodeIP;
    static {
        try {
            nodeIP = InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getPropertyValue() {
        return NodeIpProperty.nodeIP;
    }
}

//logback.xml中添加如下配置,该配置位于configuration标签下
<define name="NODE_IP" class="***.***.util.logback.NodeIpProperty"/>

该方式引用时为 ${NODE_IP}
 
以上，不是什么新东西，只是在实际工作中遇到的坑，希望能帮到遇到同样问题的伙伴